text,length,is_long_context,metric_val,label_metric
"#include ""caching_metric.h""
#include ""metric.h""
#include ""description_utils.h""
#include ""classification_utils.h""
#include ""kappa.h""

#include <catboost/libs/helpers/dispatch_generic_lambda.h>
#include <catboost/libs/helpers/math_utils.h>
#include <catboost/libs/helpers/vector_helpers.h>
#include <catboost/private/libs/options/data_processing_options.h>
#include <catboost/private/libs/options/enum_helpers.h>
#include <util/generic/string.h>
#include <util/generic/set.h>

using NCB::AppendTemporaryMetricsVector;
using NCB::AsVector;

constexpr int BinaryClassesCount = 2;
static const TString ConfusionMatrixCacheKey = ""Confusion Matrix"";
static const TString MultiLabelConfusionMatrixCacheKey = ""MultiLabel Confusion Matrix"";

/* Caching metric */

namespace {
    class ICacheHolder {
    public:
        virtual ~ICacheHolder() = default;
    };

    template <typename TValue, typename... TKeys>
    class TCacheHolder : public ICacheHolder {
    public:
        template <typename TValueMaker>
        TValue& Get(TValueMaker maker, const TKeys & ...keys) {
            auto key = std::make_tuple(keys...);
            if (!Cache.contains(key)) {
                Cache.insert({key, maker()});
            }

            return Cache.at(key);
        }

    private:
        TMap<std::tuple<TKeys...>, TValue> Cache;
    };

    class TCache {
    public:
        template <typename TValueMaker, typename... TKeys>
        auto Get(const TString& cacheKey, TValueMaker maker, TKeys... keys) -> const decltype(maker()) & {
            if (!Cache.contains(cacheKey)) {
                Cache.insert({cacheKey, MakeHolder<TCacheHolder<decltype(maker()), TKeys...>>()});
            }

            auto cache = dynamic_cast<TCacheHolder<decltype(maker()), TKeys...> *>(Cache.at(cacheKey).Get());
            CB_ENSURE(cache, ""Cache is typed differently"");
            return cache->Get(maker, keys...);
        }

    private:
        TMap<TString, THolder<ICacheHolder>> Cache;
    };

    struct ICachingSingleTargetEval {
        virtual TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            bool isExpApprox,
            TConstArrayRef<float> target,
            TConstArrayRef<float> weight,
            TConstArrayRef<TQueryInfo> queriesInfo,
            int begin,
            int end,
            TMaybe<TCache*> cache
        ) const = 0;
    };

    struct ICachingMultiTargetEval {
        virtual TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            TConstArrayRef<TConstArrayRef<float>> target,
            TConstArrayRef<float> weight,
            int begin,
            int end,
            TMaybe<TCache*> cache
        ) const = 0;
    };

    template <typename TEvalFunc>
    static TMetricHolder ParallelEvalIfPossible(
        const IMetric& metric,
        TEvalFunc&& evalFunc,
        int begin,
        int end,
        NPar::ILocalExecutor& executor
    ) {
        if (metric.IsAdditiveMetric()) {
            return ParallelEvalMetric(evalFunc, GetMinBlockSize(end - begin), begin, end, executor);
        } else {
            return evalFunc(begin, end);
        }
    }

    struct TCachingSingleTargetMetric: public TSingleTargetMetric, ICachingSingleTargetEval {
        explicit TCachingSingleTargetMetric(ELossFunction lossFunction, const TLossParams& params)
            : TSingleTargetMetric(lossFunction, params)
            {}
        using ICachingSingleTargetEval::Eval;
        TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            bool isExpApprox,
            TConstArrayRef<float> target,
            TConstArrayRef<float> weight,
            TConstArrayRef<TQueryInfo> queriesInfo,
            int begin,
            int end,
            NPar::ILocalExecutor& executor
        ) const override {
            const auto evalMetric = [&](int from, int to) {
                return Eval(approx, approxDelta, isExpApprox, target, weight, queriesInfo, from, to, Nothing());
            };
            return ParallelEvalIfPossible(*this, evalMetric, begin, end, executor);
        }
    };

    struct TCachingMultiTargetMetric: public TMultiTargetMetric, ICachingMultiTargetEval {
        explicit TCachingMultiTargetMetric(ELossFunction lossFunction, const TLossParams& params)
            : TMultiTargetMetric(lossFunction, params)
            {}
        using ICachingMultiTargetEval::Eval;
        virtual TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            TConstArrayRef<TConstArrayRef<float>> target,
            TConstArrayRef<float> weight,
            int begin,
            int end,
            NPar::ILocalExecutor& executor
        ) const override {
            const auto evalMetric = [&](int from, int to) {
                return Eval(approx, approxDelta, target, weight, from, to, Nothing());
            };
            return ParallelEvalIfPossible(*this, evalMetric, begin, end, executor);
        }
    };

    struct TCachingUniversalMetric: public TUniversalMetric, ICachingSingleTargetEval, ICachingMultiTargetEval {
        explicit TCachingUniversalMetric(ELossFunction lossFunction, const TLossParams& params)
            : TUniversalMetric(lossFunction, params)
            {}
        using ISingleTargetEval::Eval;
        using ICachingSingleTargetEval::Eval;
        TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            bool isExpApprox,
            TConstArrayRef<float> target,
            TConstArrayRef<float> weight,
            TConstArrayRef<TQueryInfo> queriesInfo,
            int begin,
            int end,
            NPar::ILocalExecutor& executor
        ) const override {
            const auto evalMetric = [&](int from, int to) {
                return Eval(approx, approxDelta, isExpApprox, target, weight, queriesInfo, from, to, Nothing());
            };
            return ParallelEvalIfPossible(*this, evalMetric, begin, end, executor);
        }

        using IMultiTargetEval::Eval;
        using ICachingMultiTargetEval::Eval;
        virtual TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            TConstArrayRef<TConstArrayRef<float>> target,
            TConstArrayRef<float> weight,
            int begin,
            int end,
            NPar::ILocalExecutor& executor
        ) const override {
            const auto evalMetric = [&](int from, int to) {
                return Eval(approx, approxDelta, target, weight, from, to, Nothing());
            };
            return ParallelEvalIfPossible(*this, evalMetric, begin, end, executor);
        }
    };
}
/* Confusion matrix */

static TMetricHolder BuildConfusionMatrix(
    const TConstArrayRef<TConstArrayRef<double>> approx,
    TConstArrayRef<float> target,
    TConstArrayRef<float> weight,
    int begin,
    int end,
    double targetBorder,
    double predictionBorder
) {
    const bool isMultiClass = approx.size() > 1;
    const int classesCount = isMultiClass ? approx.size() : BinaryClassesCount;
    const double predictionLogitBorder = NCB::Logit(predictionBorder);

    const auto buildImpl = [&](auto useWeights, auto isMultiClass) {
        TMetricHolder confusionMatrix(classesCount * classesCount);
        for (int idx = begin; idx < end; ++idx) {
            int approxClass = GetApproxClass(approx, idx, predictionLogitBorder);
            int targetClass = isMultiClass ? static_cast<int>(target[idx]) : target[idx] > targetBorder;
            float w = useWeights ? weight[idx] : 1;

            Y_ASSERT(targetClass >= 0 && targetClass < classesCount);

            confusionMatrix.Stats[approxClass * classesCount + targetClass] += w;
        }
        return confusionMatrix;
    };

    return DispatchGenericLambda(buildImpl, !weight.empty(), isMultiClass);
}

/* MultiLabel Confusion matrix */
constexpr size_t BinaryConfusionMatrixSize = 4;

static TMetricHolder BuildConfusionMatrix(
    const TConstArrayRef<TConstArrayRef<double>> approx,
    TConstArrayRef<TConstArrayRef<float>> target,
    TConstArrayRef<float> weight,
    int begin,
    int end,
    double targetBorder,
    double predictionBorder
) {
    const int classesCount = approx.size();
    TMetricHolder confusionMatrix(BinaryConfusionMatrixSize * classesCount);
    for (int classIdx = 0; classIdx < classesCount; ++classIdx) {
        TConstArrayRef<TConstArrayRef<double>> classApprox(&approx[classIdx], 1);
        TMetricHolder classConfusionMatrix = BuildConfusionMatrix(
            classApprox, target[classIdx], weight, begin, end, targetBorder, predictionBorder
        );
        for (size_t i = 0; i < BinaryConfusionMatrixSize; ++i) {
            confusionMatrix.Stats[classIdx * BinaryConfusionMatrixSize + i] = classConfusionMatrix.Stats[i];
        }
    }
    return confusionMatrix;
}

/* MCC caching metric */

namespace {
    struct TMCCCachingMetric final : public TCachingSingleTargetMetric {
        explicit TMCCCachingMetric(const TLossParams& params,
                                   int classesCount)
            : TCachingSingleTargetMetric(ELossFunction::MCC, params)
            , ClassesCount(classesCount) {
        }
        explicit TMCCCachingMetric(const TLossParams& params,
                                   double predictionBorder)
            : TCachingSingleTargetMetric(ELossFunction::MCC, params)
            , PredictionBorder(predictionBorder)
        {
        }
        using TSingleTargetMetric::Eval;
        TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            bool isExpApprox,
            TConstArrayRef<float> target,
            TConstArrayRef<float> weight,
            TConstArrayRef<TQueryInfo> queriesInfo,
            int begin,
            int end,
            TMaybe<TCache*> cache
        ) const override;
        double GetFinalError(const TMetricHolder &error) const override;
        void GetBestValue(EMetricBestValue *valueType, float *bestPossibleValue) const override;
        bool IsAdditiveMetric() const override {
            return true;
        }
        static TVector<TParamSet> ValidParamSets();

    private:
        static constexpr double TargetBorder = GetDefaultTargetBorder();
        const int ClassesCount = BinaryClassesCount;
        const double PredictionBorder = GetDefaultPredictionBorder();
    };
}

THolder<IMetric> MakeMCCMetric(const TLossParams& params, int classesCount) {
    return MakeHolder<TMCCCachingMetric>(params, classesCount);
}

TMetricHolder TMCCCachingMetric::Eval(
    const TConstArrayRef<TConstArrayRef<double>> approx,
    const TConstArrayRef<TConstArrayRef<double>> approxDelta,
    bool isExpApprox,
    TConstArrayRef<float> target,
    TConstArrayRef<float> weight,
    TConstArrayRef<TQueryInfo> /*queriesInfo*/,
    int begin,
    int end,
    TMaybe<TCache*> cache
) const {
    Y_ASSERT(!isExpApprox);
    Y_ASSERT(approxDelta.empty());

    const auto makeMatrix = [&]() {
        return BuildConfusionMatrix(approx, target, UseWeights ? weight : TVector<float>{}, begin, end,
                TargetBorder, PredictionBorder);
    };
    auto confusionMatrix = cache.Empty() ? makeMatrix() : cache.GetRef()->Get(ConfusionMatrixCacheKey, makeMatrix, bool(UseWeights),
            TargetBorder, PredictionBorder);

    return confusionMatrix;
}

double TMCCCachingMetric::GetFinalError(const TMetricHolder &error) const {
    TVector<double> rowSum(ClassesCount);
    TVector<double> columnSum(ClassesCount);
    double totalSum = 0;

    const auto getStats = [&](int i, int j) { return error.Stats[i * ClassesCount + j]; };
    for (auto i : xrange(ClassesCount)) {
        for (auto j : xrange(ClassesCount)) {
            rowSum[i] += getStats(i, j);
            columnSum[j] += getStats(i, j);
            totalSum += getStats(i, j);
        }
    }

    double numerator = 0;
    for (auto i : xrange(ClassesCount)) {
        numerator += getStats(i, i) * totalSum - rowSum[i] * columnSum[i];
    }

    double sumSquareRowSums = 0;
    double sumSquareColumnSums = 0;
    for (auto i : xrange(ClassesCount)) {
        sumSquareRowSums += Sqr(rowSum[i]);
        sumSquareColumnSums += Sqr(columnSum[i]);
    }

    double denominator = sqrt((Sqr(totalSum) - sumSquareRowSums) * (Sqr(totalSum) - sumSquareColumnSums));
    return denominator != 0 ? numerator / denominator : 0.0;
}

void TMCCCachingMetric::GetBestValue(EMetricBestValue *valueType, float *) const {
    *valueType = EMetricBestValue::Max;
}

TVector<TParamSet> TMCCCachingMetric::ValidParamSets() {
    return {TParamSet{{TParamInfo{""use_weights"", false, true}}, """"}};
};

/* Zero one loss caching metric */

namespace {
    struct TZeroOneLossCachingMetric final: public TCachingSingleTargetMetric {
        explicit TZeroOneLossCachingMetric(const TLossParams& params,
                                           int classesCount)
            : TCachingSingleTargetMetric(ELossFunction::ZeroOneLoss, params)
            , ClassesCount(classesCount) {
        }
        explicit TZeroOneLossCachingMetric(const TLossParams& params,
                                           double predictionBorder)
            : TCachingSingleTargetMetric(ELossFunction::ZeroOneLoss, params)
            , PredictionBorder(predictionBorder) {
        }
        using TSingleTargetMetric::Eval;
        TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            bool isExpApprox,
            TConstArrayRef<float> target,
            TConstArrayRef<float> weight,
            TConstArrayRef<TQueryInfo> queriesInfo,
            int begin,
            int end,
            TMaybe<TCache*> cache
        ) const override;
        double GetFinalError(const TMetricHolder &error) const override;
        void GetBestValue(EMetricBestValue *valueType, float *bestPossibleValue) const override;
        bool IsAdditiveMetric() const override {
            return true;
        }

        static TVector<TParamSet> ValidParamSets();

    private:
        static constexpr double TargetBorder = GetDefaultTargetBorder();
        const int ClassesCount = BinaryClassesCount;
        const double PredictionBorder = GetDefaultPredictionBorder();
    };
}

TMetricHolder TZeroOneLossCachingMetric::Eval(
    const TConstArrayRef<TConstArrayRef<double>> approx,
    const TConstArrayRef<TConstArrayRef<double>> approxDelta,
    bool isExpApprox,
    TConstArrayRef<float> target,
    TConstArrayRef<float> weight,
    TConstArrayRef<TQueryInfo> /*queriesInfo*/,
    int begin,
    int end,
    TMaybe<TCache*> cache
) const {
    Y_ASSERT(!isExpApprox);
    Y_ASSERT(approxDelta.empty());

    const auto makeMatrix = [&]() {
        return BuildConfusionMatrix(approx, target, UseWeights ? weight : TVector<float>{}, begin, end,
                TargetBorder, PredictionBorder);
    };
    auto confusionMatrix = cache.Empty() ? makeMatrix() : cache.GetRef()->Get(ConfusionMatrixCacheKey, makeMatrix, bool(UseWeights),
            TargetBorder, PredictionBorder);

    const auto getStats = [&](int i, int j) { return confusionMatrix.Stats[i * ClassesCount + j]; };
    TMetricHolder error(2);
    for (auto i : xrange(ClassesCount)) {
        error.Stats[0] += getStats(i, i);
        for (auto j : xrange(ClassesCount)) {
            error.Stats[1] += getStats(i, j);
        }
    }
    return error;
}

double TZeroOneLossCachingMetric::GetFinalError(const TMetricHolder &error) const {
    return 1 - error.Stats[0] / error.Stats[1];
}

void TZeroOneLossCachingMetric::GetBestValue(EMetricBestValue *valueType, float *) const {
    *valueType = EMetricBestValue::Min;
}

TVector<TParamSet> TZeroOneLossCachingMetric::ValidParamSets() {
    return {TParamSet{{TParamInfo{""use_weights"", false, true}}, """"}};
};

/* Accuracy caching metric */

namespace {
    struct TAccuracyCachingMetric final: public TCachingUniversalMetric {
        explicit TAccuracyCachingMetric(const TLossParams& params,
                                        double predictionBorder)
            : TCachingUniversalMetric(ELossFunction::Accuracy, params)
            , PredictionBorder(predictionBorder) {
        }
        explicit TAccuracyCachingMetric(const TLossParams& params,
                                        int classesCount)
            : TCachingUniversalMetric(ELossFunction::Accuracy, params)
            , ClassesCount(classesCount) {
        }
        explicit TAccuracyCachingMetric(const TLossParams& params,
                                        int classesCount,
                                        int classIdx)
            : TCachingUniversalMetric(ELossFunction::Accuracy, params)
            , ClassesCount(classesCount)
            , AccuracyType(EAccuracyType::PerClass)
            , ClassIdx(classIdx) {
        }
        using ISingleTargetEval::Eval;
        TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            bool isExpApprox,
            TConstArrayRef<float> target,
            TConstArrayRef<float> weight,
            TConstArrayRef<TQueryInfo> /*queriesInfo*/,
            int begin,
            int end,
            TMaybe<TCache *> cache
        ) const override;

        using IMultiTargetEval::Eval;
        TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            TConstArrayRef<TConstArrayRef<float>> target,
            TConstArrayRef<float> weight,
            int begin,
            int end,
            TMaybe<TCache*> cache
        ) const override;

        void GetBestValue(EMetricBestValue* valueType, float* bestValue) const override;
        TString GetDescription() const override;
        bool IsAdditiveMetric() const override {
            return true;
        }

        static TVector<TParamSet> ValidParamSets();

    private:
        static constexpr double TargetBorder = GetDefaultTargetBorder();
        const double PredictionBorder = GetDefaultPredictionBorder();
        const int ClassesCount = BinaryClassesCount;
        const EAccuracyType AccuracyType = EAccuracyType::Classic;
        const int ClassIdx = 0;
    };
}

TMetricHolder TAccuracyCachingMetric::Eval(
    const TConstArrayRef<TConstArrayRef<double>> approx,
    const TConstArrayRef<TConstArrayRef<double>> approxDelta,
    bool isExpApprox,
    TConstArrayRef<float> target,
    TConstArrayRef<float> weight,
    TConstArrayRef<TQueryInfo> /*queriesInfo*/,
    int begin,
    int end,
    TMaybe<TCache*> cache
) const {
    Y_ASSERT(!isExpApprox);
    Y_ASSERT(approxDelta.empty());
    CB_ENSURE(AccuracyType == EAccuracyType::Classic, ""PerClass accuracy is meaningfull for multilabel only"");

    const auto makeMatrix = [&]() {
        return BuildConfusionMatrix(approx, target, UseWeights ? weight : TVector<float>{}, begin, end,
                TargetBorder, PredictionBorder);
    };
    auto confusionMatrix = cache.Empty() ? makeMatrix() : cache.GetRef()->Get(ConfusionMatrixCacheKey, makeMatrix, bool(UseWeights),
            TargetBorder, PredictionBorder);

    const auto getStats = [&](int i, int j) { return confusionMatrix.Stats[i * ClassesCount + j]; };
    TMetricHolder error(2);
    for (auto i : xrange(ClassesCount)) {
        error.Stats[0] += getStats(i, i);
        for (auto j : xrange(ClassesCount)) {
            error.Stats[1] += getStats(i, j);
        }
    }
    return error;
}

TMetricHolder TAccuracyCachingMetric::Eval(
    TConstArrayRef<TConstArrayRef<double>> approx,
    TConstArrayRef<TConstArrayRef<double>> approxDelta,
    TConstArrayRef<TConstArrayRef<float>> target,
    TConstArrayRef<float> weight,
    int begin,
    int end,
    TMaybe<TCache*> cache
) const {
    Y_ASSERT(approxDelta.empty());

    TMetricHolder error(2);
    if (AccuracyType == EAccuracyType::PerClass) {
        const auto makeMatrix = [&]() {
            return BuildConfusionMatrix(approx, target, UseWeights ? weight : TVector<float>{}, begin, end,
                    TargetBorder, PredictionBorder);
        };
        auto confusionMatrix = cache.Empty() ? makeMatrix() : cache.GetRef()->Get(MultiLabelConfusionMatrixCacheKey,
                                                                                  makeMatrix, bool(UseWeights),
                                                                                  TargetBorder, PredictionBorder);

        const auto getStats = [&](int i, int j) {
            return confusionMatrix.Stats[ClassIdx * BinaryConfusionMatrixSize + i * 2 + j];
        };
        for (auto i : xrange(2)) {
            error.Stats[0] += getStats(i, i);
            for (auto j : xrange(2)) {
                error.Stats[1] += getStats(i, j);
            }
        }
    } else {
        const double predictionLogitBorder = NCB::Logit(PredictionBorder);
        const bool useWeights = !weight.empty();

        for (int idx = begin; idx < end; ++idx) {
            bool correct = true;
            for (int targetDim = 0; targetDim < target.ysize() && correct; ++targetDim) {
                const int approxClass = approx[targetDim][idx] > predictionLogitBorder;
                const int targetClass = target[targetDim][idx] > TargetBorder;
                correct &= approxClass == targetClass;
            }
            const double w = useWeights ? weight[idx] : 1.0f;
            error.Stats[0] += w * correct;
            error.Stats[1] += w;
        }
    }
    return error;
}

void TAccuracyCachingMetric::GetBestValue(EMetricBestValue* valueType, float*) const {
    *valueType = EMetricBestValue::Max;
}

TString TAccuracyCachingMetric::GetDescription() const {
    if (AccuracyType == EAccuracyType::PerClass) {
        const TMetricParam<int> classIdx(""class"", ClassIdx, /*userDefined*/true);
        return BuildDescription(ELossFunction::Accuracy, UseWeights, classIdx);
    } else {
        return TCachingUniversalMetric::GetDescription();
    }
}

TVector<TParamSet> TAccuracyCachingMetric::ValidParamSets() {
    return {TParamSet{
        {
            TParamInfo{""use_weights"", false, true},
            TParamInfo{""type"", false, ToString(EAccuracyType::Classic)}
        },
        """"
    }};
};

/* HammingLoss caching metric */

namespace {
    struct THammingLossCachingMetric final: public TCachingUniversalMetric {
        explicit THammingLossCachingMetric(const TLossParams& params,
                                           double predictionBorder)
            : TCachingUniversalMetric(ELossFunction::HammingLoss, params)
            , PredictionBorder(predictionBorder) {
        }
        explicit THammingLossCachingMetric(const TLossParams& params,
                                           int classesCount)
            : TCachingUniversalMetric(ELossFunction::HammingLoss, params)
            , ClassesCount(classesCount) {
        }

        using ISingleTargetEval::Eval;
        TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            bool isExpApprox,
            TConstArrayRef<float> target,
            TConstArrayRef<float> weight,
            TConstArrayRef<TQueryInfo> /*queriesInfo*/,
            int begin,
            int end,
            TMaybe<TCache *> cache
        ) const override;

        using IMultiTargetEval::Eval;
        TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            TConstArrayRef<TConstArrayRef<float>> target,
            TConstArrayRef<float> weight,
            int begin,
            int end,
            TMaybe<TCache*> cache
        ) const override;

        void GetBestValue(EMetricBestValue* valueType, float* bestValue) const override;
        bool IsAdditiveMetric() const override {
            return true;
        }

        static TVector<TParamSet> ValidParamSets();

    private:
        static constexpr double TargetBorder = GetDefaultTargetBorder();
        const double PredictionBorder = GetDefaultPredictionBorder();
        const int ClassesCount = BinaryClassesCount;
    };
}

TMetricHolder THammingLossCachingMetric::Eval(
    const TConstArrayRef<TConstArrayRef<double>> approx,
    const TConstArrayRef<TConstArrayRef<double>> approxDelta,
    bool isExpApprox,
    TConstArrayRef<float> target,
    TConstArrayRef<float> weight,
    TConstArrayRef<TQueryInfo> /*queriesInfo*/,
    int begin,
    int end,
    TMaybe<TCache*> cache
) const {
    Y_ASSERT(!isExpApprox);
    Y_ASSERT(approxDelta.empty());

    const auto makeMatrix = [&]() {
        return BuildConfusionMatrix(approx, target, UseWeights ? weight : TVector<float>{}, begin, end,
                TargetBorder, PredictionBorder);
    };
    auto confusionMatrix = cache.Empty() ? makeMatrix() : cache.GetRef()->Get(ConfusionMatrixCacheKey, makeMatrix, bool(UseWeights),
            TargetBorder, PredictionBorder);

    const auto getStats = [&](int i, int j) { return confusionMatrix.Stats[i * ClassesCount + j]; };
    TMetricHolder error(2);
    for (auto i : xrange(ClassesCount)) {
        error.Stats[0] += getStats(i, i);
        for (auto j : xrange(ClassesCount)) {
            error.Stats[1] += getStats(i, j);
        }
    }
    error.Stats[0] = error.Stats[1] - error.Stats[0];
    return error;
}

TMetricHolder THammingLossCachingMetric::Eval(
    TConstArrayRef<TConstArrayRef<double>> approx,
    TConstArrayRef<TConstArrayRef<double>> approxDelta,
    TConstArrayRef<TConstArrayRef<float>> target,
    TConstArrayRef<float> weight,
    int begin,
    int end,
    TMaybe<TCache*> cache
) const {
    Y_ASSERT(approxDelta.empty());

    TMetricHolder error(2);
    const auto makeMatrix = [&]() {
        return BuildConfusionMatrix(approx, target, UseWeights ? weight : TVector<float>{}, begin, end,
                TargetBorder, PredictionBorder);
    };
    auto confusionMatrix = cache.Empty() ? makeMatrix() : cache.GetRef()->Get(MultiLabelConfusionMatrixCacheKey,
                                                                              makeMatrix, bool(UseWeights),
                                                                              TargetBorder, PredictionBorder);

    for (auto classIdx : xrange(ClassesCount)) {
        const auto getStats = [&](int i, int j) {
            return confusionMatrix.Stats[classIdx * BinaryConfusionMatrixSize + i * 2 + j];
        };
        for (auto i : xrange(2)) {
            error.Stats[0] += getStats(i, 1 - i);
            for (auto j : xrange(2)) {
                error.Stats[1] += getStats(i, j);
            }
        }
    }

    return error;
}

void THammingLossCachingMetric::GetBestValue(EMetricBestValue* valueType, float*) const {
    *valueType = EMetricBestValue::Min;
}

TVector<TParamSet> THammingLossCachingMetric::ValidParamSets() {
    return {
        TParamSet{
            {
                TParamInfo{""use_weights"", false, true},
                TParamInfo{""border"", false, TargetBorder}
            },
            """"
        }
    };
};

/* Recall caching metric */

namespace {
    struct TRecallCachingMetric final: public TCachingUniversalMetric {
        explicit TRecallCachingMetric(const TLossParams& params,
                                      double predictionBorder)
            : TCachingUniversalMetric(ELossFunction::Recall, params)
            , ClassesCount(BinaryClassesCount)
            , PredictionBorder(predictionBorder)
            , IsMultiClass(false) {
        }

        explicit TRecallCachingMetric(const TLossParams& params,
                                      int classesCount, int positiveClass)
            : TCachingUniversalMetric(ELossFunction::Recall, params)
            , ClassesCount(classesCount)
            , PositiveClass(positiveClass)
            , IsMultiClass(true) {
        }

        using ISingleTargetEval::Eval;
        TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            bool isExpApprox,
            TConstArrayRef<float> target,
            TConstArrayRef<float> weight,
            TConstArrayRef<TQueryInfo> /*queriesInfo*/,
            int begin,
            int end,
            TMaybe<TCache*> cache
        ) const override;

        using IMultiTargetEval::Eval;
        TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            TConstArrayRef<TConstArrayRef<float>> target,
            TConstArrayRef<float> weight,
            int begin,
            int end,
            TMaybe<TCache*> cache
        ) const override;

        TString GetDescription() const override;
        double GetFinalError(const TMetricHolder& error) const override;
        void GetBestValue(EMetricBestValue* valueType, float* bestValue) const override;
        bool IsAdditiveMetric() const override {
            return true;
        }

        static TVector<TParamSet> ValidParamSets();

    private:
        static constexpr double TargetBorder = GetDefaultTargetBorder();
        const int ClassesCount = BinaryClassesCount;
        const int PositiveClass = 1;
        const double PredictionBorder = GetDefaultPredictionBorder();
        const bool IsMultiClass = false;
    };
}

THolder<IMetric> MakeBinClassRecallMetric(const TLossParams& params,
                                          double predictionBorder) {
    return MakeHolder<TRecallCachingMetric>(params, predictionBorder);
}

THolder<IMetric> MakeMultiClassRecallMetric(const TLossParams& params,
                                            int classesCount, int positiveClass) {
    return MakeHolder<TRecallCachingMetric>(params, classesCount, positiveClass);
}

TMetricHolder TRecallCachingMetric::Eval(
    const TConstArrayRef<TConstArrayRef<double>> approx,
    const TConstArrayRef<TConstArrayRef<double>> approxDelta,
    bool isExpApprox,
    TConstArrayRef<float> target,
    TConstArrayRef<float> weight,
    TConstArrayRef<TQueryInfo> /*queriesInfo*/,
    int begin,
    int end,
    TMaybe<TCache*> cache
) const {
    Y_ASSERT(!isExpApprox);
    Y_ASSERT(approxDelta.empty());

    const auto makeMatrix = [&]() {
        return BuildConfusionMatrix(approx, target, UseWeights ? weight : TVector<float>{}, begin, end,
                TargetBorder, PredictionBorder);
    };
    auto confusionMatrix = cache.Empty() ? makeMatrix() : cache.GetRef()->Get(ConfusionMatrixCacheKey, makeMatrix, bool(UseWeights), TargetBorder, PredictionBorder);

    const auto getStats = [&](int i, int j) { return confusionMatrix.Stats[i * ClassesCount + j]; };
    TMetricHolder error(2);
    error.Stats[0] = getStats(PositiveClass, PositiveClass);
    for (auto i : xrange(ClassesCount)) {
        error.Stats[1] += getStats(i, PositiveClass);
    }
    return error;
}

TMetricHolder TRecallCachingMetric::Eval(
    TConstArrayRef<TConstArrayRef<double>> approx,
    TConstArrayRef<TConstArrayRef<double>> approxDelta,
    TConstArrayRef<TConstArrayRef<float>> target,
    TConstArrayRef<float> weight,
    int begin,
    int end,
    TMaybe<TCache*> cache
) const {
    Y_ASSERT(approxDelta.empty());

    TMetricHolder error(2);
    const auto makeMatrix = [&]() {
        return BuildConfusionMatrix(approx, target, UseWeights ? weight : TVector<float>{}, begin, end,
                TargetBorder, PredictionBorder);
    };
    auto confusionMatrix = cache.Empty() ? makeMatrix() : cache.GetRef()->Get(MultiLabelConfusionMatrixCacheKey,
                                                                              makeMatrix, bool(UseWeights),
                                                                              TargetBorder, PredictionBorder);

    const auto getStats = [&](int i, int j) {
        return confusionMatrix.Stats[PositiveClass * BinaryConfusionMatrixSize + i * 2 + j];
    };
    error.Stats[0] = getStats(1, 1);
    error.Stats[1] = getStats(1, 1) + getStats(0, 1);

    return error;
}

TString TRecallCachingMetric::GetDescription() const {
    if (IsMultiClass) {
        const TMetricParam<int> positiveClass(""class"", PositiveClass, /*userDefined*/true);
        return BuildDescription(ELossFunction::Recall, UseWeights, positiveClass);
    } else {
        return BuildDescription(ELossFunction::Recall, UseWeights, ""%.3g"", MakeTargetBorderParam(TargetBorder),
                                MakePredictionBorderParam(PredictionBorder));
    }
}

double TRecallCachingMetric::GetFinalError(const TMetricHolder& error) const {
    return error.Stats[1] != 0 ? error.Stats[0] / error.Stats[1] : 1;
}

void TRecallCachingMetric::GetBestValue(EMetricBestValue* valueType, float*) const {
    *valueType = EMetricBestValue::Max;
}

TVector<TParamSet> TRecallCachingMetric::ValidParamSets() {
    return {TParamSet{{TParamInfo{""use_weights"", false, true}}, """"}};
};

/* Precision caching metric */

namespace {
    struct TPrecisionCachingMetric final: public TCachingUniversalMetric {
        explicit TPrecisionCachingMetric(const TLossParams& params,
                                         double predictionBorder)
            : TCachingUniversalMetric(ELossFunction::Precision, params)
            , ClassesCount(BinaryClassesCount)
            , PredictionBorder(predictionBorder)
            , IsMultiClass(false) {
        }

        explicit TPrecisionCachingMetric(const TLossParams& params,
                                         int classesCount, int positiveClass)
            : TCachingUniversalMetric(ELossFunction::Precision, params)
            , ClassesCount(classesCount)
            , PositiveClass(positiveClass)
            , IsMultiClass(true) {
        }

        using ISingleTargetEval::Eval;
        TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            bool isExpApprox,
            TConstArrayRef<float> target,
            TConstArrayRef<float> weight,
            TConstArrayRef<TQueryInfo> /*queriesInfo*/,
            int begin,
            int end,
            TMaybe<TCache *> cache
        ) const override;

        using IMultiTargetEval::Eval;
        TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            TConstArrayRef<TConstArrayRef<float>> target,
            TConstArrayRef<float> weight,
            int begin,
            int end,
            TMaybe<TCache*> cache
        ) const override;

        TString GetDescription() const override;
        double GetFinalError(const TMetricHolder& error) const override;
        void GetBestValue(EMetricBestValue* valueType, float* bestValue) const override;
        bool IsAdditiveMetric() const override {
            return true;
        }

        static TVector<TParamSet> ValidParamSets();

    private:
        static constexpr double TargetBorder = GetDefaultTargetBorder();
        const int ClassesCount = BinaryClassesCount;
        const int PositiveClass = 1;
        const double PredictionBorder = GetDefaultPredictionBorder();
        const bool IsMultiClass = false;
    };
}

THolder<IMetric> MakeBinClassPrecisionMetric(const TLossParams& params,
                                             double predictionBorder) {
    return MakeHolder<TPrecisionCachingMetric>(params, predictionBorder);
}

THolder<IMetric> MakeMultiClassPrecisionMetric(const TLossParams& params,
                                               int classesCount, int positiveClass) {
    return MakeHolder<TPrecisionCachingMetric>(params, classesCount, positiveClass);
}

TMetricHolder TPrecisionCachingMetric::Eval(
    const TConstArrayRef<TConstArrayRef<double>> approx,
    const TConstArrayRef<TConstArrayRef<double>> approxDelta,
    bool isExpApprox,
    TConstArrayRef<float> target,
    TConstArrayRef<float> weight,
    TConstArrayRef<TQueryInfo> /*queriesInfo*/,
    int begin,
    int end,
    TMaybe<TCache*> cache
) const {
    Y_ASSERT(!isExpApprox);
    Y_ASSERT(approxDelta.empty());

    const auto makeMatrix = [&]() {
        return BuildConfusionMatrix(approx, target, UseWeights ? weight : TVector<float>{}, begin, end,
                TargetBorder, PredictionBorder);
    };
    auto confusionMatrix = cache.Empty() ? makeMatrix() : cache.GetRef()->Get(ConfusionMatrixCacheKey, makeMatrix, bool(UseWeights), TargetBorder, PredictionBorder);

    const auto getStats = [&](int i, int j) { return confusionMatrix.Stats[i * ClassesCount + j]; };
    TMetricHolder error(2);
    error.Stats[0] = getStats(PositiveClass, PositiveClass);
    for (auto i : xrange(ClassesCount)) {
        error.Stats[1] += getStats(PositiveClass, i);
    }

    return error;
}

TMetricHolder TPrecisionCachingMetric::Eval(
    TConstArrayRef<TConstArrayRef<double>> approx,
    TConstArrayRef<TConstArrayRef<double>> approxDelta,
    TConstArrayRef<TConstArrayRef<float>> target,
    TConstArrayRef<float> weight,
    int begin,
    int end,
    TMaybe<TCache*> cache
) const {
    Y_ASSERT(approxDelta.empty());

    TMetricHolder error(2);
    const auto makeMatrix = [&]() {
        return BuildConfusionMatrix(approx, target, UseWeights ? weight : TVector<float>{}, begin, end,
                TargetBorder, PredictionBorder);
    };
    auto confusionMatrix = cache.Empty() ? makeMatrix() : cache.GetRef()->Get(MultiLabelConfusionMatrixCacheKey,
                                                                              makeMatrix, bool(UseWeights),
                                                                              TargetBorder, PredictionBorder);

    const auto getStats = [&](int i, int j) {
        return confusionMatrix.Stats[PositiveClass * BinaryConfusionMatrixSize + i * 2 + j];
    };
    error.Stats[0] = getStats(1, 1);
    error.Stats[1] = getStats(1, 1) + getStats(1, 0);

    return error;
}

TString TPrecisionCachingMetric::GetDescription() const {
    if (IsMultiClass) {
        const TMetricParam<int> positiveClass(""class"", PositiveClass, /*userDefined*/true);
        return BuildDescription(ELossFunction::Precision, UseWeights, positiveClass);
    } else {
        return BuildDescription(ELossFunction::Precision, UseWeights, ""%.3g"", MakeTargetBorderParam(TargetBorder),
                                MakePredictionBorderParam(PredictionBorder));
    }
}

double TPrecisionCachingMetric::GetFinalError(const TMetricHolder& error) const {
    return error.Stats[1] != 0 ? error.Stats[0] / error.Stats[1] : 1;
}

void TPrecisionCachingMetric::GetBestValue(EMetricBestValue* valueType, float*) const {
    *valueType = EMetricBestValue::Max;
}

TVector<TParamSet> TPrecisionCachingMetric::ValidParamSets() {
    return {TParamSet{{TParamInfo{""use_weights"", false, true}}, """"}};
};

/* F beta caching metric */

namespace {
    struct TFCachingMetric: public TCachingUniversalMetric {
        explicit TFCachingMetric(const TLossParams& params, double beta,
                                 double predictionBorder)
            : TCachingUniversalMetric(ELossFunction::F, params)
            , ClassesCount(BinaryClassesCount)
            , Beta(beta)
            , PredictionBorder(predictionBorder)
            , IsMultiClass(false)
        {
            Y_ASSERT(Beta > 0);
        }

        explicit TFCachingMetric(const TLossParams& params, double beta,
                                 int classesCount, int positiveClass)
            : TCachingUniversalMetric(ELossFunction::F, params)
            , ClassesCount(classesCount)
            , PositiveClass(positiveClass)
            , Beta(beta)
            , IsMultiClass(true)
        {
            Y_ASSERT(Beta > 0);
        }

        using ISingleTargetEval::Eval;
        TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            bool isExpApprox,
            TConstArrayRef<float> target,
            TConstArrayRef<float> weight,
            TConstArrayRef<TQueryInfo> /*queriesInfo*/,
            int begin,
            int end,
            TMaybe<TCache *> cache
        ) const override;

        using IMultiTargetEval::Eval;
        TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            TConstArrayRef<TConstArrayRef<float>> target,
            TConstArrayRef<float> weight,
            int begin,
            int end,
            TMaybe<TCache*> cache
        ) const override;

        TString GetDescription() const override;
        TVector<TString> GetStatDescriptions() const override;
        double GetFinalError(const TMetricHolder& error) const override;
        void GetBestValue(EMetricBestValue* valueType, float* bestValue) const override;
        bool IsAdditiveMetric() const override {
            return true;
        }

        static TVector<TParamSet> ValidParamSets();

    protected:
        static constexpr double TargetBorder = GetDefaultTargetBorder();
        const int ClassesCount = BinaryClassesCount;
        const int PositiveClass = 1;
        const double Beta = 1;
        const double PredictionBorder = GetDefaultPredictionBorder();
        const bool IsMultiClass = false;
    };
}

THolder<IMetric> MakeBinClassFMetric(const TLossParams& params, double beta,
                                     double predictionBorder) {
    return MakeHolder<TFCachingMetric>(params, beta, predictionBorder);
}

THolder<IMetric> MakeMultiClassFMetric(const TLossParams& params, double beta,
                                       int classesCount, int positiveClass) {
    return MakeHolder<TFCachingMetric>(params, beta, classesCount, positiveClass);
}

TMetricHolder TFCachingMetric::Eval(
    const TConstArrayRef<TConstArrayRef<double>> approx,
    const TConstArrayRef<TConstArrayRef<double>> approxDelta,
    bool isExpApprox,
    TConstArrayRef<float> target,
    TConstArrayRef<float> weight,
    TConstArrayRef<TQueryInfo> /*queriesInfo*/,
    int begin,
    int end,
    TMaybe<TCache*> cache
) const {
    Y_ASSERT(!isExpApprox);
    Y_ASSERT(approxDelta.empty());

    const auto makeMatrix = [&]() {
        return BuildConfusionMatrix(approx, target, UseWeights ? weight : TVector<float>{}, begin, end,
                                    TargetBorder, PredictionBorder);
    };
    auto confusionMatrix = cache.Empty() ? makeMatrix() : cache.GetRef()->Get(ConfusionMatrixCacheKey, makeMatrix, bool(UseWeights), TargetBorder, PredictionBorder);

    const auto getStats = [&](int i, int j) { return confusionMatrix.Stats[i * ClassesCount + j]; };
    TMetricHolder error(3);
    error.Stats[0] = getStats(PositiveClass, PositiveClass);
    for (auto i : xrange(ClassesCount)) {
        error.Stats[1] += getStats(PositiveClass, i);
        error.Stats[2] += getStats(i, PositiveClass);
    }
    return error;
}

TMetricHolder TFCachingMetric::Eval(
    TConstArrayRef<TConstArrayRef<double>> approx,
    TConstArrayRef<TConstArrayRef<double>> approxDelta,
    TConstArrayRef<TConstArrayRef<float>> target,
    TConstArrayRef<float> weight,
    int begin,
    int end,
    TMaybe<TCache*> cache
) const {
    Y_ASSERT(approxDelta.empty());

    const auto makeMatrix = [&]() {
        return BuildConfusionMatrix(approx, target, UseWeights ? weight : TVector<float>{}, begin, end,
                                    TargetBorder, PredictionBorder);
    };
    auto confusionMatrix = cache.Empty() ? makeMatrix() : cache.GetRef()->Get(MultiLabelConfusionMatrixCacheKey,
                                                                              makeMatrix, bool(UseWeights),
                                                                              TargetBorder, PredictionBorder);

    const auto getStats = [&](int i, int j) {
        return confusionMatrix.Stats[PositiveClass * BinaryConfusionMatrixSize + i * 2 + j];
    };
    TMetricHolder error(3);
    error.Stats[0] = getStats(1, 1);
    error.Stats[1] = getStats(1, 1) + getStats(1, 0);
    error.Stats[2] = getStats(1, 1) + getStats(0, 1);
    return error;
}

TVector<TString> TFCachingMetric::GetStatDescriptions() const {
    return {""TP"", ""TP+FP"", ""TP+FN""};
}

TString TFCachingMetric::GetDescription() const {
    const TMetricParam<double> beta(""beta"", Beta, /*userDefined*/true);
    if (IsMultiClass) {
        const TMetricParam<int> positiveClass(""class"", PositiveClass, /*userDefined*/true);
        return BuildDescription(ELossFunction::F, UseWeights, ""%.3g"", beta, positiveClass);
    } else {
        return BuildDescription(ELossFunction::F, UseWeights, ""%.3g"", beta,""%.3g"", MakeTargetBorderParam(TargetBorder),
                                MakePredictionBorderParam(PredictionBorder));
    }
}

double TFCachingMetric::GetFinalError(const TMetricHolder& error) const {
    double precision = error.Stats[1] != 0 ? error.Stats[0] / error.Stats[1] : 1.0;
    double recall = error.Stats[2] != 0 ? error.Stats[0] / error.Stats[2] : 1.0;
    double beta_square = Beta * Beta;
    return precision + recall != 0 ? (1 + beta_square) * precision * recall / (beta_square * precision + recall) : 0.0;
}

void TFCachingMetric::GetBestValue(EMetricBestValue* valueType, float*) const {
    *valueType = EMetricBestValue::Max;
}

TVector<TParamSet> TFCachingMetric::ValidParamSets() {
    return {
        TParamSet{
            {
                TParamInfo{""use_weights"", false, true},
                TParamInfo{""beta"", true, {}}
            },
            """"
        }
    };
}

/* F1 caching metric */

namespace {
    struct TF1CachingMetric final : public TFCachingMetric {
        explicit TF1CachingMetric(const TLossParams &params,
                                  double predictionBorder)
            : TFCachingMetric(params, 1.0, predictionBorder) {
        }

        explicit TF1CachingMetric(const TLossParams &params,
                                  int classesCount, int positiveClass)
            : TFCachingMetric(params, 1.0, classesCount, positiveClass) {
        }
        TString GetDescription() const override;

        static TVector<TParamSet> ValidParamSets();
    };
}

THolder<IMetric> MakeBinClassF1Metric(const TLossParams& params,
                                      double predictionBorder) {
    return MakeHolder<TF1CachingMetric>(params, predictionBorder);
}

THolder<IMetric> MakeMultiClassF1Metric(const TLossParams& params,
                                        int classesCount, int positiveClass) {
    return MakeHolder<TF1CachingMetric>(params, classesCount, positiveClass);
}



TString TF1CachingMetric::GetDescription() const {
    if (IsMultiClass) {
        const TMetricParam<int> positiveClass(""class"", PositiveClass, /*userDefined*/true);
        return BuildDescription(ELossFunction::F1, UseWeights, positiveClass);
    } else {
        return BuildDescription(ELossFunction::F1, UseWeights, ""%.3g"", MakeTargetBorderParam(TargetBorder),
                                MakePredictionBorderParam(PredictionBorder));
    }
}


TVector<TParamSet> TF1CachingMetric::ValidParamSets() {
    return {TParamSet{{TParamInfo{""use_weights"", false, true}}, """"}};
};

/* TotalF1 caching metric */

namespace {
    struct TTotalF1CachingMetric final: public TCachingSingleTargetMetric {
        static constexpr int StatsCardinality = 3;

        explicit TTotalF1CachingMetric(const TLossParams& params,
                                       double predictionBorder, EF1AverageType averageType)
            : TCachingSingleTargetMetric(ELossFunction::TotalF1, params)
            , ClassesCount(BinaryClassesCount)
            , PredictionBorder(predictionBorder)
            , AverageType(averageType) {
        }

        explicit TTotalF1CachingMetric(const TLossParams& params,
                                       int classesCount, EF1AverageType averageType)
            : TCachingSingleTargetMetric(ELossFunction::TotalF1, params)
            , ClassesCount(classesCount)
            , AverageType(averageType) {
        }

        using TSingleTargetMetric::Eval;
        TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            bool isExpApprox,
            TConstArrayRef<float> target,
            TConstArrayRef<float> weight,
            TConstArrayRef<TQueryInfo> /*queriesInfo*/,
            int begin,
            int end,
            TMaybe<TCache *> cache
        ) const override;

        TVector<TString> GetStatDescriptions() const override;
        double GetFinalError(const TMetricHolder& error) const override;
        void GetBestValue(EMetricBestValue* valueType, float* bestValue) const override;
        bool IsAdditiveMetric() const override {
            return true;
        }

        static TVector<TParamSet> ValidParamSets();

    private:
        static constexpr double TargetBorder = GetDefaultTargetBorder();
        const int ClassesCount = BinaryClassesCount;
        const double PredictionBorder = GetDefaultPredictionBorder();
        const EF1AverageType AverageType;
    };
}

THolder<IMetric> MakeTotalF1Metric(const TLossParams& params,
                                   int classesCount, EF1AverageType averageType) {
    return MakeHolder<TTotalF1CachingMetric>(params, classesCount, averageType);
}

TMetricHolder TTotalF1CachingMetric::Eval(
    const TConstArrayRef<TConstArrayRef<double>> approx,
    const TConstArrayRef<TConstArrayRef<double>> approxDelta,
    bool isExpApprox,
    TConstArrayRef<float> target,
    TConstArrayRef<float> weight,
    TConstArrayRef<TQueryInfo> /*queriesInfo*/,
    int begin,
    int end,
    TMaybe<TCache*> cache
) const {
    Y_ASSERT(!isExpApprox);
    Y_ASSERT(approxDelta.empty());

    const auto makeMatrix = [&]() {
        return BuildConfusionMatrix(approx, target, UseWeights ? weight : TVector<float>{}, begin, end,
                TargetBorder, PredictionBorder);
    };
    auto confusionMatrix = cache.Empty() || 1 ? makeMatrix() : cache.GetRef()->Get(ConfusionMatrixCacheKey, makeMatrix, bool(UseWeights), TargetBorder, PredictionBorder);

    const auto getStats = [&](int i, int j) { return confusionMatrix.Stats[i * ClassesCount + j]; };
    TVector<double> classTruePositive(ClassesCount);
    TVector<double> classSize(ClassesCount);
    TVector<double> classPredictedSize(ClassesCount);

    for (auto i : xrange(ClassesCount)) {
        classTruePositive[i] = getStats(i, i);
        for (auto j : xrange(ClassesCount)) {
            classSize[i] += getStats(j, i);
            classPredictedSize[i] += getStats(i, j);
        }
    }

    TMetricHolder error(StatsCardinality * ClassesCount);
    for (auto i : xrange(ClassesCount)) {
        error.Stats[StatsCardinality * i + 0] = classSize[i];
        error.Stats[StatsCardinality * i + 1] = classPredictedSize[i];
        error.Stats[StatsCardinality * i + 2] = classTruePositive[i];
    }
    return error;
}

TVector<TString> TTotalF1CachingMetric::GetStatDescriptions() const {
    TVector<TString> description;
    for (auto classIdx : xrange(ClassesCount)) {
        auto prefix = ""Class="" + ToString(classIdx) + "","";
        description.push_back(prefix + ""TP+FN"");
        description.push_back(prefix + ""TP+FP"");
        description.push_back(prefix + ""TP"");
    }
    return description;
}

double TTotalF1CachingMetric::GetFinalError(const TMetricHolder& error) const {
    double numerator = 0.0;
    double denumerator = 0.0;

    for (auto i : xrange(ClassesCount)) {
        double classSize = error.Stats[StatsCardinality * i + 0];
        double classPredictedSize = error.Stats[StatsCardinality * i + 1];
        double truePositive = error.Stats[StatsCardinality * i + 2];

        double f1 = classSize + classPredictedSize != 0 ? 2 * truePositive / (classSize + classPredictedSize) : 0.0;

        if (AverageType == EF1AverageType::Weighted) {
            numerator += f1 * classSize;
            denumerator += classSize;
        } else if (AverageType == EF1AverageType::Micro) {
            numerator += 2 * truePositive;
            denumerator += classSize + classPredictedSize;
        } else if (AverageType == EF1AverageType::Macro) {
            numerator += f1;
            denumerator += 1;
        }
    }

    return numerator / denumerator;
}

void TTotalF1CachingMetric::GetBestValue(EMetricBestValue* valueType, float*) const {
    *valueType = EMetricBestValue::Max;
}

TVector<TParamSet> TTotalF1CachingMetric::ValidParamSets() {
    return {
        TParamSet{
            {
                TParamInfo{""use_weights"", false, true},
                TParamInfo{""average"", false, ToString(EF1AverageType::Weighted)}
            },
            """"
        }
    };
};

/* Kappa */

namespace {
    struct TKappaMetric final: public TCachingSingleTargetMetric {
        explicit TKappaMetric(const TLossParams& params,
                              int classCount = 2, double predictionBorder = GetDefaultPredictionBorder())
            : TCachingSingleTargetMetric(ELossFunction::Kappa, params)
            , TargetBorder(GetDefaultTargetBorder())
            , PredictionBorder(predictionBorder)
            , ClassCount(classCount) {
        }

        static TVector<THolder<IMetric>> Create(const TMetricConfig& config);
        static TVector<TParamSet> ValidParamSets();

        using TSingleTargetMetric::Eval;
        TMetricHolder Eval(
                const TConstArrayRef<TConstArrayRef<double>> approx,
                const TConstArrayRef<TConstArrayRef<double>> approxDelta,
                bool isExpApprox,
                TConstArrayRef<float> target,
                TConstArrayRef<float> weight,
                TConstArrayRef<TQueryInfo> queriesInfo,
                int begin,
                int end,
                TMaybe<TCache*> cache
        ) const override;
        TString GetDescription() const override;
        double GetFinalError(const TMetricHolder& error) const override;
        void GetBestValue(EMetricBestValue* valueType, float* bestValue) const override;
        bool IsAdditiveMetric() const override {
            return true;
        }

    private:
        const double TargetBorder = GetDefaultTargetBorder();
        const double PredictionBorder = GetDefaultPredictionBorder();
        const int ClassCount;
    };
}

// static.
TVector<THolder<IMetric>> TKappaMetric::Create(const TMetricConfig& config) {
    if (config.ApproxDimension == 1) {
        config.ValidParams->insert(""border"");
        return AsVector(MakeHolder<TKappaMetric>(config.Params, /*classCount=*/2, config.GetPredictionBorderOrDefault()));
    } else {
        return AsVector(MakeHolder<TKappaMetric>(config.Params, config.ApproxDimension));
    }
}

TMetricHolder TKappaMetric::Eval(
    const TConstArrayRef<TConstArrayRef<double>> approx,
    const TConstArrayRef<TConstArrayRef<double>> approxDelta,
    bool isExpApprox,
    TConstArrayRef<float> target,
    TConstArrayRef<float> weight,
    TConstArrayRef<TQueryInfo> /*queriesInfo*/,
    int begin,
    int end,
    TMaybe<TCache*> cache
) const {
    Y_ASSERT(approxDelta.empty());
    Y_ASSERT(!isExpApprox);

    const auto makeMatrix = [&]() {
        return BuildConfusionMatrix(approx, target, UseWeights ? weight : TVector<float>{}, begin, end,
                TargetBorder, PredictionBorder);
    };
    return cache.Empty() || 1 ? makeMatrix() : cache.GetRef()->Get(ConfusionMatrixCacheKey, makeMatrix, bool(UseWeights), TargetBorder, PredictionBorder);
}

TString TKappaMetric::GetDescription() const {
    return BuildDescription(ELossFunction::Kappa, ""%.3g"", MakeTargetBorderParam(TargetBorder),
                            MakePredictionBorderParam(PredictionBorder));
}

void TKappaMetric::GetBestValue(EMetricBestValue* valueType, float*) const {
    *valueType = EMetricBestValue::Max;
}

double TKappaMetric::GetFinalError(const TMetricHolder& error) const {
    return CalcKappa(error, ClassCount, EKappaMetricType::Cohen);
}

TVector<TParamSet> TKappaMetric::ValidParamSets() {
    return {TParamSet{{TParamInfo{""use_weights"", false, true}}, """"}};
};

/* WKappa */

namespace {
    struct TWKappaMetric final: public TCachingSingleTargetMetric {
        explicit TWKappaMetric(const TLossParams& params,
                               int classCount = 2, double predictionBorder = GetDefaultPredictionBorder())
            : TCachingSingleTargetMetric(ELossFunction::WKappa, params)
            , TargetBorder(GetDefaultTargetBorder())
            , PredictionBorder(predictionBorder)
            , ClassCount(classCount) {
        }

        static TVector<THolder<IMetric>> Create(const TMetricConfig& config);

        static TVector<TParamSet> ValidParamSets();

        using TSingleTargetMetric::Eval;
        TMetricHolder Eval(
            TConstArrayRef<TConstArrayRef<double>> approx,
            TConstArrayRef<TConstArrayRef<double>> approxDelta,
            bool isExpApprox,
            TConstArrayRef<float> target,
            TConstArrayRef<float> weight,
            TConstArrayRef<TQueryInfo> queriesInfo,
            int begin,
            int end,
            TMaybe<TCache*> cache
        ) const override;

        TString GetDescription() const override;
        double GetFinalError(const TMetricHolder& error) const override;
        void GetBestValue(EMetricBestValue *valueType, float *bestValue) const override;
        bool IsAdditiveMetric() const override {
            return true;
        }

    private:
        const double TargetBorder = GetDefaultTargetBorder();
        const double PredictionBorder = GetDefaultPredictionBorder();
        const int ClassCount;
    };
}

// static.
TVector<THolder<IMetric>> TWKappaMetric::Create(const TMetricConfig& config) {
    if (config.ApproxDimension == 1) {
        config.ValidParams->insert(""border"");
        return AsVector(MakeHolder<TWKappaMetric>(config.Params, /*classCount=*/2, config.GetPredictionBorderOrDefault()));
    } else {
        return AsVector(MakeHolder<TWKappaMetric>(config.Params, config.ApproxDimension));
    }
}

TMetricHolder TWKappaMetric::Eval(
    const TConstArrayRef<TConstArrayRef<double>> approx,
    const TConstArrayRef<TConstArrayRef<double>> approxDelta,
    bool isExpApprox,
    TConstArrayRef<float> target,
    TConstArrayRef<float> weight,
    TConstArrayRef<TQueryInfo> /*queriesInfo*/,
    int begin,
    int end,
    TMaybe<TCache*> cache
) const {
    Y_ASSERT(approxDelta.empty());
    Y_ASSERT(!isExpApprox);

    const auto makeMatrix = [&]() {
        return BuildConfusionMatrix(approx, target, UseWeights ? weight : TVector<float>{}, begin, end,
                TargetBorder, PredictionBorder);
    };
    return cache.Empty() || 1 ? makeMatrix() : cache.GetRef()->Get(ConfusionMatrixCacheKey, makeMatrix, bool(UseWeights), TargetBorder, PredictionBorder);
}

TString TWKappaMetric::GetDescription() const {
    return BuildDescription(ELossFunction::WKappa, ""%.3g"", MakeTargetBorderParam(TargetBorder),
                            MakePredictionBorderParam(PredictionBorder));
}

void TWKappaMetric::GetBestValue(EMetricBestValue* valueType, float*) const {
    *valueType = EMetricBestValue::Max;
}

double TWKappaMetric::GetFinalError(const TMetricHolder& error) const {
    return CalcKappa(error, ClassCount, EKappaMetricType::Weighted);
}

TVector<TParamSet> TWKappaMetric::ValidParamSets() {
    return {TParamSet{{TParamInfo{""use_weights"", false, true}}, """"}};
};

TVector<TMetricHolder> EvalErrorsWithCaching(
    const TVector<TVector<double>>& approx,
    const TVector<TVector<double>>& approxDelta,
    bool isExpApprox,
    TConstArrayRef<TConstArrayRef<float>> target,
    TConstArrayRef<float> weight,
    TConstArrayRef<TQueryInfo> queriesInfo,
    TConstArrayRef<const IMetric*> metrics,
    NPar::ILocalExecutor* localExecutor
) {
    const auto threadCount = localExecutor->GetThreadCount() + 1;
    const auto objectCount = approx.front().size();
    const auto queryCount = queriesInfo.size();

    const auto approxRef = To2DConstArrayRef<double>(approx);
    const auto approxDeltaRef = To2DConstArrayRef<double>(approxDelta);

    const auto calcCaching = [&](auto metric, auto from, auto to, auto *cache) {
        if (target.size() <= 1 && dynamic_cast<const ICachingSingleTargetEval*>(metric) != nullptr) {
            CB_ENSURE(!metric->NeedTarget() || target.size() == 1, ""Metric ["" + metric->GetDescription() + ""] requires ""
                    << (target.size() > 1 ? ""one-dimensional"" : """") <<  ""target"");
            return dynamic_cast<const ICachingSingleTargetEval*>(metric)->Eval(
                approxRef, approxDeltaRef, isExpApprox,
                metric->NeedTarget() ? target[0] : TConstArrayRef<float>(),
                weight, queriesInfo, from, to, cache
            );
        } else {
            CB_ENSURE(!isExpApprox, ""Metric ["" << metric->GetDescription() << ""] does not support exponentiated approxes"");
            return dynamic_cast<const ICachingMultiTargetEval*>(metric)->Eval(
                approxRef, approxDeltaRef, target, weight, from, to, cache
            );
        }
    };
    const auto calcNonCaching = [&](auto metric, auto from, auto to) {
        if (target.size() <= 1 && dynamic_cast<const ISingleTargetEval*>(metric) != nullptr) {
            CB_ENSURE(!metric->NeedTarget() || target.size() == 1, ""Metric ["" + metric->GetDescription() + ""] requires ""
                    << (target.size() > 1 ? ""one-dimensional"" : """") <<  ""target"");
            return dynamic_cast<const ISingleTargetEval*>(metric)->Eval(
                approxRef, approxDeltaRef, isExpApprox,
                metric->NeedTarget() ? target[0] : TConstArrayRef<float>(),
                weight, queriesInfo, from, to, *localExecutor
            );
        } else {
            CB_ENSURE(!isExpApprox, ""Metric ["" << metric->GetDescription() << ""] does not support exponentiated approxes"");
            return dynamic_cast<const IMultiTargetEval*>(metric)->Eval(
                approxRef, approxDeltaRef, target, weight, from, to, *localExecutor
            );
        }
    };

    TVector<TMetricHolder> errors;
    errors.reserve(metrics.size());

    NPar::ILocalExecutor::TExecRangeParams objectwiseBlockParams(0, objectCount);
    if (!target.empty()) {
        const auto objectwiseEffectiveBlockCount = Min(threadCount, int(ceil(double(objectCount) / GetMinBlockSize(objectCount))));
        objectwiseBlockParams.SetBlockCount(objectwiseEffectiveBlockCount);
    }

    NPar::ILocalExecutor::TExecRangeParams querywiseBlockParams(0, queryCount);
    if (!queriesInfo.empty()) {
        const auto querywiseEffectiveBlockCount = Min(threadCount, int(ceil(double(queryCount) / GetMinBlockSize(objectCount))));
        querywiseBlockParams.SetBlockCount(querywiseEffectiveBlockCount);
    }

    TCache nonAdditiveCache;
    TVector<TCache> objectwiseAdditiveCache(objectwiseBlockParams.GetBlockCount());
    TVector<TCache> querywiseAdditiveCache(querywiseBlockParams.GetBlockCount());
    TVector<TMetricHolder> objectwiseBlockResults(objectwiseBlockParams.GetBlockCount());
    TVector<TMetricHolder> querywiseBlockResults(querywiseBlockParams.GetBlockCount());

    for (auto i : xrange(metrics.size())) {
        auto metric = metrics[i];

        const bool isObjectwise = metric->GetErrorType() == EErrorType::PerObjectError;
        const auto end = isObjectwise ? objectCount : queryCount;

        const bool isCaching = dynamic_cast<const ICachingSingleTargetEval*>(metric)
                            || dynamic_cast<const ICachingMultiTargetEval*>(metric);

        if (isCaching && metric->IsAdditiveMetric()) {
            const auto blockSize = isObjectwise ? objectwiseBlockParams.GetBlockSize() : querywiseBlockParams.GetBlockSize();
            const auto blockCount = isObjectwise ? objectwiseBlockParams.GetBlockCount() : querywiseBlockParams.GetBlockCount();

            auto &results = isObjectwise ? objectwiseBlockResults : querywiseBlockResults;
            auto &cache = isObjectwise ? objectwiseAdditiveCache : querywiseAdditiveCache;

            NPar::ParallelFor(*localExecutor, 0, blockCount, [&](auto blockId) {
                const auto from = blockId * blockSize;
                const auto to = Min<int>((blockId + 1) * blockSize, end);
                results[blockId] = calcCaching(metric, from, to, &cache[blockId]);
            });

            TMetricHolder error;
            for (const auto &blockResult : results) {
                error.Add(blockResult);
            }
            errors.push_back(error);
        } else {
            if (isCaching) {
                errors.push_back(calcCaching(metric, 0, end, &nonAdditiveCache));
            } else {
                errors.push_back(calcNonCaching(metric, 0, end));
            }
        }
    }

    return errors;
}

template <typename TMetricType>
static TVector<THolder<IMetric>> CreateMetric(int approxDimension, const TMetricConfig& config) {
    TVector<THolder<IMetric>> result;
    if (approxDimension == 1) {
        result.emplace_back(MakeHolder<TMetricType>(config.Params, config.GetPredictionBorderOrDefault()));
    } else {
        result.emplace_back(MakeHolder<TMetricType>(config.Params, approxDimension));
    }
    return result;
}

template <typename TMetricType>
static TVector<THolder<IMetric>> CreateMetricClasswise(int approxDimension, const TMetricConfig& config) {
    TVector<THolder<IMetric>> result;
    if (approxDimension == 1) {
        result.emplace_back(MakeHolder<TMetricType>(config.Params, config.GetPredictionBorderOrDefault()));
    } else {
        for (int i : xrange(approxDimension)) {
            result.emplace_back(MakeHolder<TMetricType>(config.Params, approxDimension, i));
        }
    }
    return result;
}

TVector<THolder<IMetric>> CreateCachingMetrics(const TMetricConfig& config) {
    *config.ValidParams = TSet<TString>{};
    TVector<THolder<IMetric>> result;

    switch(config.Metric) {
        case ELossFunction::F1: {
            return CreateMetricClasswise<TF1CachingMetric>(config.ApproxDimension, config);
        }
        case ELossFunction::F:  {
            CB_ENSURE(config.GetParamsMap().contains(""beta""), ""Metric "" << ELossFunction::F << "" requires beta as parameter"");
            config.ValidParams->insert(""beta"");
            double beta_param = FromString<float>(config.GetParamsMap().at(""beta""));

            if (config.ApproxDimension == 1) {
                result.emplace_back(MakeHolder<TFCachingMetric>(config.Params, beta_param, config.GetPredictionBorderOrDefault()));
            } else {
                for (int i : xrange(config.ApproxDimension)) {
                    result.emplace_back(MakeHolder<TFCachingMetric>(config.Params, beta_param, config.ApproxDimension, i));
                }
            }
            return result;
        }
        case ELossFunction::TotalF1: {
            config.ValidParams->insert(""average"");
            EF1AverageType averageType = EF1AverageType::Weighted;
            if (config.GetParamsMap().contains(""average"")) {
                averageType = FromString<EF1AverageType>(config.GetParamsMap().at(""average""));
            }

            if (config.ApproxDimension == 1) {
                result.emplace_back(MakeHolder<TTotalF1CachingMetric>(config.Params, config.GetPredictionBorderOrDefault(), averageType));
            } else {
                result.emplace_back(MakeHolder<TTotalF1CachingMetric>(config.Params, config.ApproxDimension, averageType));
            }
            return result;
        }
        case ELossFunction::MCC: {
            return CreateMetric<TMCCCachingMetric>(config.ApproxDimension, config);
        }
        case ELossFunction::BrierScore: {
            CB_ENSURE(config.ApproxDimension == 1, ""Brier Score is used only for binary classification problems."");
            result.emplace_back(MakeBrierScoreMetric(config.Params));
            return result;
        }
        case ELossFunction::ZeroOneLoss: {
            return CreateMetric<TZeroOneLossCachingMetric>(config.ApproxDimension, config);
        }
        case ELossFunction::HammingLoss: {
            return CreateMetric<THammingLossCachingMetric>(config.ApproxDimension, config);
        }
        case ELossFunction::Accuracy: {
            config.ValidParams->insert(""type"");
            EAccuracyType accuracyType = EAccuracyType::Classic;
            if (config.GetParamsMap().contains(""type"")) {
                accuracyType = FromString<EAccuracyType>(config.GetParamsMap().at(""type""));
            }
            if (accuracyType == EAccuracyType::Classic) {
                return CreateMetric<TAccuracyCachingMetric>(config.ApproxDimension, config);
            } else if (accuracyType == EAccuracyType::PerClass) {
                return CreateMetricClasswise<TAccuracyCachingMetric>(config.ApproxDimension, config);
            } else {
                CB_ENSURE_INTERNAL(false, ""Unhandled accuracy type "" << accuracyType);
            }
        }
        case ELossFunction::CtrFactor: {
            result.emplace_back(MakeCtrFactorMetric(config.Params));
            return result;
        }
        case ELossFunction::Precision: {
            return CreateMetricClasswise<TPrecisionCachingMetric>(config.ApproxDimension, config);
        }
        case ELossFunction::Recall:
            return CreateMetricClasswise<TRecallCachingMetric>(config.ApproxDimension, config);
            break;
        case ELossFunction::Kappa:
            AppendTemporaryMetricsVector(TKappaMetric::Create(config), &result);
            break;

        case ELossFunction::WKappa:
            AppendTemporaryMetricsVector(TWKappaMetric::Create(config), &result);
            break;
        default:
            break;
    }

    return result;
}

TVector<TParamSet> CachingMetricValidParamSets(ELossFunction metric) {
    switch (metric) {
        case ELossFunction::F:
            return TFCachingMetric::ValidParamSets();
        case ELossFunction::F1:
            return TF1CachingMetric::ValidParamSets();
        case ELossFunction::TotalF1:
            return TTotalF1CachingMetric::ValidParamSets();
        case ELossFunction::MCC:
            return TMCCCachingMetric::ValidParamSets();
        case ELossFunction::ZeroOneLoss:
            return TZeroOneLossCachingMetric::ValidParamSets();
        case ELossFunction::Accuracy:
            return TAccuracyCachingMetric::ValidParamSets();
        case ELossFunction::HammingLoss:
            return THammingLossCachingMetric::ValidParamSets();
        case ELossFunction::Precision:
            return TPrecisionCachingMetric::ValidParamSets();
        case ELossFunction::Recall:
            return TRecallCachingMetric::ValidParamSets();
        case ELossFunction::Kappa:
            return TKappaMetric::ValidParamSets();
        case ELossFunction::WKappa:
            return TWKappaMetric::ValidParamSets();
        default:
            CB_ENSURE(false, ""Unsupported metric: "" << metric);
    }
}
",16243,True,3830.951729207512,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.default-ssl-context:: 
Reference to the SSLContext which should be globally registered as the default.

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_.autoflush:: 
Whether every event should be immediately flushed to disk (If undefined will default to the value of synchronized).

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.jaspi-configurations._KEY_.application-context:: 
The application-context this configuration is to be associated with or '*' for all application contexts.

thorntail.elytron.jaspi-configurations._KEY_.description:: 
Description of this configuration.

thorntail.elytron.jaspi-configurations._KEY_.layer:: 
The layer this configuration is to be associated with or '*' for all layers.

thorntail.elytron.jaspi-configurations._KEY_.server-auth-modules:: 
List of ServerAuthModule definitions for this configuration.

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_.autoflush:: 
Whether every event should be immediately flushed to disk (If undefined will default to the value of synchronized).

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.register-jaspi-factory:: 
Should the Elytron JASPI factory be globally registered?

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.server-ssl-sni-contexts._KEY_.default-ssl-context:: 
The context to use if no SNI information is present, or if it does not match any mappings

thorntail.elytron.server-ssl-sni-contexts._KEY_.host-context-map:: 
A mapping between a server name and an SSContext

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 flushed to disk (If undefined will default to the value of synchronized).

thorntail.elytron.size-rotating-file-audit-logs._KEY_.autoflush:: 
Whether every event should be immediately flushed 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


",12496,True,3136.682585105019,median
"
////
This file is generated! See _meta/fields.yml and scripts/generate_field_docs.py
////

[[exported-fields]]
= Exported fields

[partintro]

--
This document describes the fields that are exported by Winlogbeat. They are
grouped in the following categories:

* <<exported-fields-beat>>
* <<exported-fields-cloud>>
* <<exported-fields-common>>
* <<exported-fields-docker-processor>>
* <<exported-fields-ecs>>
* <<exported-fields-eventlog>>
* <<exported-fields-host-processor>>
* <<exported-fields-kubernetes-processor>>

--
[[exported-fields-beat]]
== Beat fields

Contains common beat fields available in all event types.



*`beat.timezone`*::
+
--
type: alias

alias to: event.timezone

--

*`fields`*::
+
--
type: object

Contains user configurable fields.


--

[float]
== error fields

Error fields containing additional info in case of errors.



*`error.type`*::
+
--
type: keyword

Error type.


--

[[exported-fields-cloud]]
== Cloud provider metadata fields

Metadata from cloud providers added by the add_cloud_metadata processor.



*`cloud.project.id`*::
+
--
example: project-x

Name of the project in Google Cloud.


--

*`meta.cloud.provider`*::
+
--
type: alias

alias to: cloud.provider

--

*`meta.cloud.instance_id`*::
+
--
type: alias

alias to: cloud.instance.id

--

*`meta.cloud.instance_name`*::
+
--
type: alias

alias to: cloud.instance.name

--

*`meta.cloud.machine_type`*::
+
--
type: alias

alias to: cloud.machine.type

--

*`meta.cloud.availability_zone`*::
+
--
type: alias

alias to: cloud.availability_zone

--

*`meta.cloud.project_id`*::
+
--
type: alias

alias to: cloud.project.id

--

*`meta.cloud.region`*::
+
--
type: alias

alias to: cloud.region

--

[[exported-fields-common]]
== Common Winlogbeat fields

Contains common fields available in all event types.



*`type`*::
+
--
required: True

The event log API type used to read the record. The possible values are ""wineventlog"" for the Windows Event Log API or ""eventlogging"" for the Event Logging API.
The Event Logging API was designed for Windows Server 2003 or Windows 2000 operating systems. In Windows Vista, the event logging infrastructure was redesigned. On Windows Vista or later operating systems, the Windows Event Log API is used. Winlogbeat automatically detects which API to use for reading event logs.


--

[[exported-fields-docker-processor]]
== Docker fields

Docker stats collected from Docker.




*`docker.container.id`*::
+
--
type: keyword

Unique container id.


--

*`docker.container.image`*::
+
--
type: keyword

Name of the image the container was built on.


--

*`docker.container.name`*::
+
--
type: keyword

Container name.


--

*`docker.container.labels`*::
+
--
type: object

Image labels.


--

[[exported-fields-ecs]]
== ECS fields

ECS fields.



*`@timestamp`*::
+
--
type: date

example: 2016-05-23T08:05:34.853Z

required: True

Date/time when the event originated.
For log events this is the date/time when the event was generated, and not when it was read.
Required field for all events.


--

*`tags`*::
+
--
type: keyword

example: [""production"", ""env2""]

List of keywords used to tag each event.


--

*`labels`*::
+
--
type: object

example: {'application': 'foo-bar', 'env': 'production'}

Key/value pairs.
Can be used to add meta information to events. Should not contain nested objects. All values are stored as keyword.
Example: `docker` and `k8s` labels.


--

*`message`*::
+
--
type: text

example: Hello World

For log events the message field contains the log message.
In other use cases the message field can be used to concatenate different values which are then freely searchable. If multiple messages exist, they can be combined into one message.


--

[float]
== agent fields

The agent fields contain the data about the software entity, if any, that collects, detects, or observes events on a host, or takes measurements on a host. Examples include Beats. Agents may also run on observers. ECS agent.* fields shall be populated with details of the agent running on the host or observer where the event happened or the measurement was taken.



*`agent.version`*::
+
--
type: keyword

example: 6.0.0-rc2

Version of the agent.


--

*`agent.name`*::
+
--
type: keyword

example: foo

Name of the agent.
This is a name that can be given to an agent. This can be helpful if for example two Filebeat instances are running on the same host but a human readable separation is needed on which Filebeat instance data is coming from.
If no name is given, the name is often left empty.


--

*`agent.type`*::
+
--
type: keyword

example: filebeat

Type of the agent.
The agent type stays always the same and should be given by the agent used. In case of Filebeat the agent would always be Filebeat also if two Filebeat instances are run on the same machine.


--

*`agent.id`*::
+
--
type: keyword

example: 8a4f500d

Unique identifier of this agent (if one exists).
Example: For Beats this would be beat.id.


--

*`agent.ephemeral_id`*::
+
--
type: keyword

example: 8a4f500f

Ephemeral identifier of this agent (if one exists).
This id normally changes across restarts, but `agent.id` does not.


--

[float]
== client fields

A client is defined as the initiator of a network connection for events regarding sessions, connections, or bidirectional flow records. For TCP events, the client is the initiator of the TCP connection that sends the SYN packet(s). For other protocols, the client is generally the initiator or requestor in the network transaction. Some systems use the term ""originator"" to refer the client in TCP connections. The client fields describe details about the system acting as the client in the network event. Client fields are usually populated in conjuction with server fields.  Client fields are generally not populated for packet-level events. 



*`client.ip`*::
+
--
type: ip

IP address of the client.
Can be one or multiple IPv4 or IPv6 addresses.


--

*`client.port`*::
+
--
type: long

Port of the client.


--

*`client.mac`*::
+
--
type: keyword

MAC address of the client.


--

*`client.domain`*::
+
--
type: keyword

Client domain.


--

*`client.bytes`*::
+
--
type: long

example: 184

Bytes sent from the client to the server.


--

*`client.packets`*::
+
--
type: long

example: 12

Packets sent from the client to the server.


--

[float]
== geo fields

Geo fields can carry data about a specific location related to an event or geo information derived from an IP field.



*`client.geo.location`*::
+
--
type: geo_point

example: { ""lon"": -73.614830, ""lat"": 45.505918 }

Longitude and latitude.


--

*`client.geo.continent_name`*::
+
--
type: keyword

example: North America

Name of the continent.


--

*`client.geo.country_name`*::
+
--
type: keyword

example: Canada

Country name.


--

*`client.geo.region_name`*::
+
--
type: keyword

example: Quebec

Region name.


--

*`client.geo.city_name`*::
+
--
type: keyword

example: Montreal

City name.


--

*`client.geo.country_iso_code`*::
+
--
type: keyword

example: CA

Country ISO code.


--

*`client.geo.region_iso_code`*::
+
--
type: keyword

example: CA-QC

Region ISO code.


--

*`client.geo.name`*::
+
--
type: keyword

example: boston-dc

User-defined description of a location, at the level of granularity they care about.
Could be the name of their data centers, the floor number, if this describes a local physical entity, city names.
Not typically used in automated geolocation.


--

[float]
== cloud fields

Fields related to the cloud or infrastructure the events are coming from.



*`cloud.provider`*::
+
--
type: keyword

example: ec2

Name of the cloud provider. Example values are ec2, gce, or digitalocean.


--

*`cloud.availability_zone`*::
+
--
type: keyword

example: us-east-1c

Availability zone in which this host is running.


--

*`cloud.region`*::
+
--
type: keyword

example: us-east-1

Region in which this host is running.


--

*`cloud.instance.id`*::
+
--
type: keyword

example: i-1234567890abcdef0

Instance ID of the host machine.


--

*`cloud.instance.name`*::
+
--
type: keyword

Instance name of the host machine.


--

*`cloud.machine.type`*::
+
--
type: keyword

example: t2.medium

Machine type of the host machine.


--

*`cloud.account.id`*::
+
--
type: keyword

example: 666777888999

The cloud account or organization id used to identify different entities in a multi-tenant environment.
Examples: AWS account id, Google Cloud ORG Id, or other unique identifier.


--

[float]
== container fields

Container fields are used for meta information about the specific container that is the source of information. These fields help correlate data based containers from any runtime.



*`container.runtime`*::
+
--
type: keyword

example: docker

Runtime managing this container.


--

*`container.id`*::
+
--
type: keyword

Unique container id.


--

*`container.image.name`*::
+
--
type: keyword

Name of the image the container was built on.


--

*`container.image.tag`*::
+
--
type: keyword

Container image tag.


--

*`container.name`*::
+
--
type: keyword

Container name.


--

*`container.labels`*::
+
--
type: object

Image labels.


--

[float]
== destination fields

Destination fields describe details about the destination of a packet/event. Destination fields are usually populated in conjunction with source fields.



*`destination.ip`*::
+
--
type: ip

IP address of the destination.
Can be one or multiple IPv4 or IPv6 addresses.


--

*`destination.port`*::
+
--
type: long

Port of the destination.


--

*`destination.mac`*::
+
--
type: keyword

MAC address of the destination.


--

*`destination.domain`*::
+
--
type: keyword

Destination domain.


--

*`destination.bytes`*::
+
--
type: long

example: 184

Bytes sent from the destination to the source.


--

*`destination.packets`*::
+
--
type: long

example: 12

Packets sent from the destination to the source.


--

[float]
== geo fields

Geo fields can carry data about a specific location related to an event or geo information derived from an IP field.



*`destination.geo.location`*::
+
--
type: geo_point

example: { ""lon"": -73.614830, ""lat"": 45.505918 }

Longitude and latitude.


--

*`destination.geo.continent_name`*::
+
--
type: keyword

example: North America

Name of the continent.


--

*`destination.geo.country_name`*::
+
--
type: keyword

example: Canada

Country name.


--

*`destination.geo.region_name`*::
+
--
type: keyword

example: Quebec

Region name.


--

*`destination.geo.city_name`*::
+
--
type: keyword

example: Montreal

City name.


--

*`destination.geo.country_iso_code`*::
+
--
type: keyword

example: CA

Country ISO code.


--

*`destination.geo.region_iso_code`*::
+
--
type: keyword

example: CA-QC

Region ISO code.


--

*`destination.geo.name`*::
+
--
type: keyword

example: boston-dc

User-defined description of a location, at the level of granularity they care about.
Could be the name of their data centers, the floor number, if this describes a local physical entity, city names.
Not typically used in automated geolocation.


--

[float]
== ecs fields

Meta-information specific to ECS.



*`ecs.version`*::
+
--
type: keyword

example: 1.0.0-beta1

required: True

ECS version this event conforms to. `ecs.version` is a required field and must exist in all events.
When querying across multiple indices -- which may conform to slightly different ECS versions -- this field lets integrations adjust to the schema version of the events.
The current version is 1.0.0-beta1 .


--

[float]
== error fields

These fields can represent errors of any kind. Use them for errors that happen while fetching events or in cases where the event itself contains an error.



*`error.id`*::
+
--
type: keyword

Unique identifier for the error.


--

*`error.message`*::
+
--
type: text

Error message.


--

*`error.code`*::
+
--
type: keyword

Error code describing the error.


--

[float]
== event fields

The event fields are used for context information about the log or metric event itself. A log is defined as an event containing details of something that happened. Log events must include the time at which the thing happened. Examples of log events include a process starting on a host, a network packet being sent from a source to a destination, or a network connection between a client and a server being initiated or closed. A metric is defined as an event containing one or more numerical or categorical measurements and the time at which the measurement was taken. Examples of metric events include memory pressure measured on a host, or vulnerabilities measured on a scanned host.



*`event.id`*::
+
--
type: keyword

example: 8a4f500d

Unique ID to describe the event.


--

*`event.kind`*::
+
--
type: keyword

example: state

The kind of the event.
This gives information about what type of information the event contains, without being specific to the contents of the event.  Examples are `event`, `state`, `alarm`. Warning: In future versions of ECS, we plan to provide a list of acceptable values for this field, please use with caution.


--

*`event.category`*::
+
--
type: keyword

example: user-management

Event category.
This contains high-level information about the contents of the event. It is more generic than `event.action`, in the sense that typically a category contains multiple actions. Warning: In future versions of ECS, we plan to provide a list of acceptable values for this field, please use with caution.


--

*`event.action`*::
+
--
type: keyword

example: user-password-change

The action captured by the event.
This describes the information in the event. It is more specific than `event.category`. Examples are `group-add`, `process-started`, `file-created`. The value is normally defined by the implementer.


--

*`event.outcome`*::
+
--
type: keyword

example: success

The outcome of the event.
If the event describes an action, this fields contains the outcome of that action. Examples outcomes are `success` and `failure`. Warning: In future versions of ECS, we plan to provide a list of acceptable values for this field, please use with caution.


--

*`event.type`*::
+
--
type: keyword

Reserved for future usage.
Please avoid using this field for user data.


--

*`event.module`*::
+
--
type: keyword

example: mysql

Name of the module this data is coming from.
This information is coming from the modules used in Beats or Logstash.


--

*`event.dataset`*::
+
--
type: keyword

example: stats

Name of the dataset.
The concept of a `dataset` (fileset / metricset) is used in Beats as a subset of modules. It contains the information which is currently stored in metricset.name and metricset.module or fileset.name.


--

*`event.severity`*::
+
--
type: long

example: 7

Severity describes the severity of the event. What the different severity values mean can very different between use cases. It's up to the implementer to make sure severities are consistent across events.


--

*`event.original`*::
+
--
type: keyword

example: Sep 19 08:26:10 host CEF:0&#124;Security&#124; threatmanager&#124;1.0&#124;100&#124; worm successfully stopped&#124;10&#124;src=10.0.0.1 dst=2.1.2.2spt=1232

Raw text message of entire event. Used to demonstrate log integrity.
This field is not indexed and doc_values are disabled. It cannot be searched, but it can be retrieved from `_source`.


Field is not indexed.

--

*`event.hash`*::
+
--
type: keyword

example: 123456789012345678901234567890ABCD

Hash (perhaps logstash fingerprint) of raw field to be able to demonstrate log integrity.


--

*`event.duration`*::
+
--
type: long

Duration of the event in nanoseconds.
If event.start and event.end are known this value should be the difference between the end and start time.


--

*`event.timezone`*::
+
--
type: keyword

This field should be populated when the event's timestamp does not include timezone information already (e.g. default Syslog timestamps). It's optional otherwise.
Acceptable timezone formats are: a canonical ID (e.g. ""Europe/Amsterdam""), abbreviated (e.g. ""EST"") or an HH:mm differential (e.g. ""-05:00"").


--

*`event.created`*::
+
--
type: date

event.created contains the date when the event was created.
This timestamp is distinct from @timestamp in that @timestamp contains the processed timestamp. For logs these two timestamps can be different as the timestamp in the log line and when the event is read for example by Filebeat are not identical. `@timestamp` must contain the timestamp extracted from the log line, event.created when the log line is read. The same could apply to package capturing where @timestamp contains the timestamp extracted from the network package and event.created when the event was created.
In case the two timestamps are identical, @timestamp should be used.


--

*`event.start`*::
+
--
type: date

event.start contains the date when the event started or when the activity was first observed.


--

*`event.end`*::
+
--
type: date

event.end contains the date when the event ended or when the activity was last observed.


--

*`event.risk_score`*::
+
--
type: float

Risk score or priority of the event (e.g. security solutions). Use your system's original value here.


--

*`event.risk_score_norm`*::
+
--
type: float

Normalized risk score or priority of the event, on a scale of 0 to 100.
This is mainly useful if you use more than one system that assigns risk scores, and you want to see a normalized value across all systems.


--

[float]
== file fields

A file is defined as a set of information that has been created on, or has existed on a filesystem. File objects can be associated with host events, network events, and/or file events (e.g., those produced by File Integrity Monitoring [FIM] products or services). File fields provide details about the affected file associated with the event or metric.



*`file.path`*::
+
--
type: keyword

Path to the file.

--

*`file.target_path`*::
+
--
type: keyword

Target path for symlinks.

--

*`file.extension`*::
+
--
type: keyword

example: png

File extension.
This should allow easy filtering by file extensions.


--

*`file.type`*::
+
--
type: keyword

File type (file, dir, or symlink).

--

*`file.device`*::
+
--
type: keyword

Device that is the source of the file.

--

*`file.inode`*::
+
--
type: keyword

Inode representing the file in the filesystem.

--

*`file.uid`*::
+
--
type: keyword

The user ID (UID) or security identifier (SID) of the file owner.


--

*`file.owner`*::
+
--
type: keyword

File owner's username.

--

*`file.gid`*::
+
--
type: keyword

Primary group ID (GID) of the file.

--

*`file.group`*::
+
--
type: keyword

Primary group name of the file.

--

*`file.mode`*::
+
--
type: keyword

example: 416

Mode of the file in octal representation.

--

*`file.size`*::
+
--
type: long

File size in bytes (field is only added when `type` is `file`).

--

*`file.mtime`*::
+
--
type: date

Last time file content was modified.

--

*`file.ctime`*::
+
--
type: date

Last time file metadata changed.

--

[float]
== group fields

The group fields are meant to represent groups that are relevant to the event.



*`group.id`*::
+
--
type: keyword

Unique identifier for the group on the system/platform.


--

*`group.name`*::
+
--
type: keyword

Name of the group.


--

[float]
== host fields

A host is defined as a general computing instance. ECS host.* fields should be populated with details about the host on which the event happened, or on which the measurement was taken. Host types include hardware, virtual machines, Docker containers, and Kubernetes nodes.



*`host.hostname`*::
+
--
type: keyword

Hostname of the host.
It normally contains what the `hostname` command returns on the host machine.


--

*`host.name`*::
+
--
type: keyword

Name of the host.
It can contain what `hostname` returns on Unix systems, the fully qualified domain name, or a name specified by the user. The sender decides which value to use.


--

*`host.id`*::
+
--
type: keyword

Unique host id.
As hostname is not always unique, use values that are meaningful in your environment.
Example: The current usage of `beat.name`.


--

*`host.ip`*::
+
--
type: ip

Host ip address.


--

*`host.mac`*::
+
--
type: keyword

Host mac address.


--

*`host.type`*::
+
--
type: keyword

Type of host.
For Cloud providers this can be the machine type like `t2.medium`. If vm, this could be the container, for example, or other information meaningful in your environment.


--

*`host.architecture`*::
+
--
type: keyword

example: x86_64

Operating system architecture.


--

[float]
== os fields

The OS fields contain information about the operating system.



*`host.os.platform`*::
+
--
type: keyword

example: darwin

Operating system platform (such centos, ubuntu, windows).


--

*`host.os.name`*::
+
--
type: keyword

example: Mac OS X

Operating system name.


--

*`host.os.family`*::
+
--
type: keyword

example: debian

OS family (such as redhat, debian, freebsd, windows).


--

*`host.os.version`*::
+
--
type: keyword

example: 10.12.6-rc2

Operating system version as a raw string.


--

*`host.os.kernel`*::
+
--
type: keyword

example: 4.4.0-112-generic

Operating system kernel version as a raw string.


--

[float]
== geo fields

Geo fields can carry data about a specific location related to an event or geo information derived from an IP field.



*`host.geo.location`*::
+
--
type: geo_point

example: { ""lon"": -73.614830, ""lat"": 45.505918 }

Longitude and latitude.


--

*`host.geo.continent_name`*::
+
--
type: keyword

example: North America

Name of the continent.


--

*`host.geo.country_name`*::
+
--
type: keyword

example: Canada

Country name.


--

*`host.geo.region_name`*::
+
--
type: keyword

example: Quebec

Region name.


--

*`host.geo.city_name`*::
+
--
type: keyword

example: Montreal

City name.


--

*`host.geo.country_iso_code`*::
+
--
type: keyword

example: CA

Country ISO code.


--

*`host.geo.region_iso_code`*::
+
--
type: keyword

example: CA-QC

Region ISO code.


--

*`host.geo.name`*::
+
--
type: keyword

example: boston-dc

User-defined description of a location, at the level of granularity they care about.
Could be the name of their data centers, the floor number, if this describes a local physical entity, city names.
Not typically used in automated geolocation.


--

[float]
== http fields

Fields related to HTTP activity.



*`http.request.method`*::
+
--
type: keyword

example: GET, POST, PUT

Http request method.


--

*`http.request.referrer`*::
+
--
type: keyword

example: https://blog.example.com/

Referrer for this HTTP request.


--

*`http.response.status_code`*::
+
--
type: long

example: 404

Http response status code.


--

*`http.response.body`*::
+
--
type: keyword

example: Hello world

The full http response body.


--

*`http.version`*::
+
--
type: keyword

example: 1.1

Http version.


--

[float]
== log fields

Fields which are specific to log events.



*`log.level`*::
+
--
type: keyword

example: ERR

Log level of the log event.
Some examples are `WARN`, `ERR`, `INFO`.


--

*`log.original`*::
+
--
type: keyword

example: Sep 19 08:26:10 localhost My log


This is the original log message and contains the full log message before splitting it up in multiple parts.
In contrast to the `message` field which can contain an extracted part of the log message, this field contains the original, full log message. It can have already some modifications applied like encoding or new lines removed to clean up the log message.
This field is not indexed and doc_values are disabled so it can't be queried but the value can be retrieved from `_source`.


Field is not indexed.

--

[float]
== network fields

The network is defined as the communication path over which a host or network event happens. The network.* fields should be populated with details about the network activity associated with an event.



*`network.name`*::
+
--
type: keyword

example: Guest Wifi

Name given by operators to sections of their network.


--

*`network.type`*::
+
--
type: keyword

example: IPv4

In the OSI Model this would be the Network Layer. IPv4, IPv6, IPSec, PIM, etc


--

*`network.iana_number`*::
+
--
type: keyword

example: 6

IANA Protocol Number (https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml). Standardized list of protocols. This aligns well with NetFlow and sFlow related logs which use the IANA Protocol Number.


--

*`network.transport`*::
+
--
type: keyword

example: TCP

Same as network.iana_number, but instead using the Keyword name of the transport layer (UDP, TCP, IPv6-ICMP, etc.)


--

*`network.application`*::
+
--
type: keyword

example: AIM

A name given to an application. This can be arbitrarily assigned for things like microservices, but also apply to things like skype, icq, facebook, twitter. This would be used in situations where the vendor or service can be decoded such as from the source/dest IP owners, ports, or wire format.


--

*`network.protocol`*::
+
--
type: keyword

example: http

L7 Network protocol name. ex. http, lumberjack, transport protocol


--

*`network.direction`*::
+
--
type: keyword

example: inbound

Direction of the network traffic.
Recommended values are:
  * inbound
  * outbound
  * internal
  * external
  * unknown

When mapping events from a host-based monitoring context, populate this field from the host's point of view.
When mapping events from a network or perimeter-based monitoring context, populate this field from the point of view of your network perimeter.


--

*`network.forwarded_ip`*::
+
--
type: ip

example: 192.1.1.2

Host IP address when the source IP address is the proxy.


--

*`network.community_id`*::
+
--
type: keyword

example: 1:hO+sN4H+MG5MY/8hIrXPqc4ZQz0=

A hash of source and destination IPs and ports, as well as the protocol used in a communication. This is a tool-agnostic standard to identify flows.
Learn more at https://github.com/corelight/community-id-spec.


--

*`network.bytes`*::
+
--
type: long

example: 368

Total bytes transferred in both directions.
If `source.bytes` and `destination.bytes` are known, `network.bytes` is their sum.


--

*`network.packets`*::
+
--
type: long

example: 24

Total packets transferred in both directions.
If `source.packets` and `destination.packets` are known, `network.packets` is their sum.


--

[float]
== observer fields

An observer is defined as a special network, security, or application device used to detect, observe, or create network, security, or application-related events and metrics. This could be a custom hardware appliance or a server that has been configured to run special network, security, or application software. Examples include firewalls, intrusion detection/prevention systems, network monitoring sensors, web application firewalls, data loss prevention systems, and APM servers. The observer.* fields shall be populated with details of the system, if any, that detects, observes and/or creates a network, security, or application event or metric. Message queues and ETL components used in processing events or metrics are not considered observers in ECS.  



*`observer.mac`*::
+
--
type: keyword

MAC address of the observer


--

*`observer.ip`*::
+
--
type: ip

IP address of the observer.


--

*`observer.hostname`*::
+
--
type: keyword

Hostname of the observer.


--

*`observer.vendor`*::
+
--
type: keyword

observer vendor information.


--

*`observer.version`*::
+
--
type: keyword

Observer version.


--

*`observer.serial_number`*::
+
--
type: keyword

Observer serial number.


--

*`observer.type`*::
+
--
type: keyword

example: firewall

The type of the observer the data is coming from.
There is no predefined list of observer types. Some examples are `forwarder`, `firewall`, `ids`, `ips`, `proxy`, `poller`, `sensor`, `APM server`.


--

[float]
== os fields

The OS fields contain information about the operating system.



*`observer.os.platform`*::
+
--
type: keyword

example: darwin

Operating system platform (such centos, ubuntu, windows).


--

*`observer.os.name`*::
+
--
type: keyword

example: Mac OS X

Operating system name.


--

*`observer.os.family`*::
+
--
type: keyword

example: debian

OS family (such as redhat, debian, freebsd, windows).


--

*`observer.os.version`*::
+
--
type: keyword

example: 10.12.6-rc2

Operating system version as a raw string.


--

*`observer.os.kernel`*::
+
--
type: keyword

example: 4.4.0-112-generic

Operating system kernel version as a raw string.


--

[float]
== geo fields

Geo fields can carry data about a specific location related to an event or geo information derived from an IP field.



*`observer.geo.location`*::
+
--
type: geo_point

example: { ""lon"": -73.614830, ""lat"": 45.505918 }

Longitude and latitude.


--

*`observer.geo.continent_name`*::
+
--
type: keyword

example: North America

Name of the continent.


--

*`observer.geo.country_name`*::
+
--
type: keyword

example: Canada

Country name.


--

*`observer.geo.region_name`*::
+
--
type: keyword

example: Quebec

Region name.


--

*`observer.geo.city_name`*::
+
--
type: keyword

example: Montreal

City name.


--

*`observer.geo.country_iso_code`*::
+
--
type: keyword

example: CA

Country ISO code.


--

*`observer.geo.region_iso_code`*::
+
--
type: keyword

example: CA-QC

Region ISO code.


--

*`observer.geo.name`*::
+
--
type: keyword

example: boston-dc

User-defined description of a location, at the level of granularity they care about.
Could be the name of their data centers, the floor number, if this describes a local physical entity, city names.
Not typically used in automated geolocation.


--

[float]
== organization fields

The organization fields enrich data with information about the company or entity the data is associated with. These fields help you arrange or filter data stored in an index by one or multiple organizations.



*`organization.name`*::
+
--
type: keyword

Organization name.


--

*`organization.id`*::
+
--
type: keyword

Unique identifier for the organization.


--

[float]
== os fields

The OS fields contain information about the operating system.



*`os.platform`*::
+
--
type: keyword

example: darwin

Operating system platform (such centos, ubuntu, windows).


--

*`os.name`*::
+
--
type: keyword

example: Mac OS X

Operating system name.


--

*`os.family`*::
+
--
type: keyword

example: debian

OS family (such as redhat, debian, freebsd, windows).


--

*`os.version`*::
+
--
type: keyword

example: 10.12.6-rc2

Operating system version as a raw string.


--

*`os.kernel`*::
+
--
type: keyword

example: 4.4.0-112-generic

Operating system kernel version as a raw string.


--

[float]
== process fields

These fields contain information about a process. These fields can help you correlate metrics information with a process id/name from a log message.  The `process.pid` often stays in the metric itself and is copied to the global field for correlation.



*`process.pid`*::
+
--
type: long

Process id.


--

*`process.name`*::
+
--
type: keyword

example: ssh

Process name.
Sometimes called program name or similar.


--

*`process.ppid`*::
+
--
type: long

Process parent id.


--

*`process.args`*::
+
--
type: keyword

example: ['ssh', '-l', 'user', '10.0.0.16']

Process arguments.
May be filtered to protect sensitive information.


--

*`process.executable`*::
+
--
type: keyword

example: /usr/bin/ssh

Absolute path to the process executable.


--

*`process.title`*::
+
--
type: keyword

Process title.
The proctitle, some times the same as process name. Can also be different: for example a browser setting its title to the web page currently opened.


--

*`process.thread.id`*::
+
--
type: long

example: 4242

Thread ID.


--

*`process.start`*::
+
--
type: date

example: 2016-05-23T08:05:34.853Z

The time the process started.


--

*`process.working_directory`*::
+
--
type: keyword

example: /home/alice

The working directory of the process.


--

[float]
== related fields

This field set is meant to facilitate pivoting around a piece of data. Some pieces of information can be seen in many places in ECS. To facilitate searching for them, append values to their corresponding field in `related.`. A concrete example is IP addresses, which can be under host, observer, source, destination, client, server, and network.forwarded_ip. If you append all IPs to `related.ip`, you can then search for a given IP trivially, no matter where it appeared, by querying `related.ip:a.b.c.d`.



*`related.ip`*::
+
--
type: ip

All of the IPs seen on your event.


--

[float]
== server fields

A Server is defined as the responder in a network connection for events regarding sessions, connections, or bidirectional flow records. For TCP events, the server is the receiver of the initial SYN packet(s) of the TCP connection. For other protocols, the server is generally the responder in the network transaction. Some systems actually use the term ""responder"" to refer the server in TCP connections. The server fields describe details about the system acting as the server in the network event. Server fields are usually populated in conjunction with client fields. Server fields are generally not populated for packet-level events.



*`server.ip`*::
+
--
type: ip

IP address of the server.
Can be one or multiple IPv4 or IPv6 addresses.


--

*`server.port`*::
+
--
type: long

Port of the server.


--

*`server.mac`*::
+
--
type: keyword

MAC address of the server.


--

*`server.domain`*::
+
--
type: keyword

Server domain.


--

*`server.bytes`*::
+
--
type: long

example: 184

Bytes sent from the server to the client.


--

*`server.packets`*::
+
--
type: long

example: 12

Packets sent from the server to the client.


--

[float]
== geo fields

Geo fields can carry data about a specific location related to an event or geo information derived from an IP field.



*`server.geo.location`*::
+
--
type: geo_point

example: { ""lon"": -73.614830, ""lat"": 45.505918 }

Longitude and latitude.


--

*`server.geo.continent_name`*::
+
--
type: keyword

example: North America

Name of the continent.


--

*`server.geo.country_name`*::
+
--
type: keyword

example: Canada

Country name.


--

*`server.geo.region_name`*::
+
--
type: keyword

example: Quebec

Region name.


--

*`server.geo.city_name`*::
+
--
type: keyword

example: Montreal

City name.


--

*`server.geo.country_iso_code`*::
+
--
type: keyword

example: CA

Country ISO code.


--

*`server.geo.region_iso_code`*::
+
--
type: keyword

example: CA-QC

Region ISO code.


--

*`server.geo.name`*::
+
--
type: keyword

example: boston-dc

User-defined description of a location, at the level of granularity they care about.
Could be the name of their data centers, the floor number, if this describes a local physical entity, city names.
Not typically used in automated geolocation.


--

[float]
== service fields

The service fields describe the service for or from which the data was collected. These fields help you find and correlate logs for a specific service and version.



*`service.id`*::
+
--
type: keyword

example: d37e5ebfe0ae6c4972dbe9f0174a1637bb8247f6

Unique identifier of the running service.
This id should uniquely identify this service. This makes it possible to correlate logs and metrics for one specific service.
Example: If you are experiencing issues with one redis instance, you can filter on that id to see metrics and logs for that single instance.


--

*`service.name`*::
+
--
type: keyword

example: elasticsearch-metrics

Name of the service data is collected from.
The name of the service is normally user given. This allows if two instances of the same service are running on the same machine they can be differentiated by the `service.name`.
Also it allows for distributed services that run on multiple hosts to correlate the related instances based on the name.
In the case of Elasticsearch the service.name could contain the cluster name. For Beats the service.name is by default a copy of the `service.type` field if no name is specified.


--

*`service.type`*::
+
--
type: keyword

example: elasticsearch

The type of the service data is collected from.
The type can be used to group and correlate logs and metrics from one service type.
Example: If logs or metrics are collected from Elasticsearch, `service.type` would be `elasticsearch`.


--

*`service.state`*::
+
--
type: keyword

Current state of the service.


--

*`service.version`*::
+
--
type: keyword

example: 3.2.4

Version of the service the data was collected from.
This allows to look at a data set only for a specific version of a service.


--

*`service.ephemeral_id`*::
+
--
type: keyword

example: 8a4f500f

Ephemeral identifier of this service (if one exists).
This id normally changes across restarts, but `service.id` does not.


--

[float]
== source fields

Source fields describe details about the source of a packet/event. Source fields are usually populated in conjunction with destination fields.



*`source.address`*::
+
--
type: keyword

Some event source addresses are defined ambiguously. The event will sometimes list an IP, a domain or a unix socket.  You should always store the raw address in the `.address` field.
Then it should be duplicated to `.ip` or `.domain`, depending on which one it is.


--

*`source.ip`*::
+
--
type: ip

IP address of the source.
Can be one or multiple IPv4 or IPv6 addresses.


--

*`source.port`*::
+
--
type: long

Port of the source.


--

*`source.mac`*::
+
--
type: keyword

MAC address of the source.


--

*`source.domain`*::
+
--
type: keyword

Source domain.


--

*`source.bytes`*::
+
--
type: long

example: 184

Bytes sent from the source to the destination.


--

*`source.packets`*::
+
--
type: long

example: 12

Packets sent from the source to the destination.


--

[float]
== geo fields

Geo fields can carry data about a specific location related to an event or geo information derived from an IP field.



*`source.geo.location`*::
+
--
type: geo_point

example: { ""lon"": -73.614830, ""lat"": 45.505918 }

Longitude and latitude.


--

*`source.geo.continent_name`*::
+
--
type: keyword

example: North America

Name of the continent.


--

*`source.geo.country_name`*::
+
--
type: keyword

example: Canada

Country name.


--

*`source.geo.region_name`*::
+
--
type: keyword

example: Quebec

Region name.


--

*`source.geo.city_name`*::
+
--
type: keyword

example: Montreal

City name.


--

*`source.geo.country_iso_code`*::
+
--
type: keyword

example: CA

Country ISO code.


--

*`source.geo.region_iso_code`*::
+
--
type: keyword

example: CA-QC

Region ISO code.


--

*`source.geo.name`*::
+
--
type: keyword

example: boston-dc

User-defined description of a location, at the level of granularity they care about.
Could be the name of their data centers, the floor number, if this describes a local physical entity, city names.
Not typically used in automated geolocation.


--

[float]
== url fields

URL fields provide a complete URL, with scheme, host, and path.



*`url.original`*::
+
--
type: keyword

example: https://www.elastic.co:443/search?q=elasticsearch#top or /search?q=elasticsearch


Unmodified original url as seen in the event source.
Note that in network monitoring, the observed URL may be a full URL, whereas in access logs, the URL is often just represented as a path.
This field is meant to represent the URL as it was observed, complete or not.


--

*`url.full`*::
+
--
type: keyword

example: https://www.elastic.co:443/search?q=elasticsearch#top

If full URLs are important to your use case, they should be stored in `url.full`, whether this field is reconstructed or present in the event source.


--

*`url.scheme`*::
+
--
type: keyword

example: https

Scheme of the request, such as ""https"".
Note: The `:` is not part of the scheme.


--

*`url.domain`*::
+
--
type: keyword

example: www.elastic.co

Domain of the request, such as ""www.elastic.co"".
In some cases a URL may refer to an IP and/or port directly, without a domain name. In this case, the IP address would go to the `domain` field.


--

*`url.port`*::
+
--
type: integer

example: 443

Port of the request, such as 443.


--

*`url.path`*::
+
--
type: keyword

Path of the request, such as ""/search"".


--

*`url.query`*::
+
--
type: keyword

The query field describes the query string of the request, such as ""q=elasticsearch"".
The `?` is excluded from the query string. If a URL contains no `?`, there is no query field. If there is a `?` but no query, the query field exists with an empty string. The `exists` query can be used to differentiate between the two cases.


--

*`url.fragment`*::
+
--
type: keyword

Portion of the url after the `#`, such as ""top"".
The `#` is not part of the fragment.


--

*`url.username`*::
+
--
type: keyword

Username of the request.


--

*`url.password`*::
+
--
type: keyword

Password of the request.


--

[float]
== user fields

The user fields describe information about the user that is relevant to  the event. Fields can have one entry or multiple entries. If a user has more than one id, provide an array that includes all of them.



*`user.id`*::
+
--
type: keyword

One or multiple unique identifiers of the user.


--

*`user.name`*::
+
--
type: keyword

example: albert

Short name or login of the user.


--

*`user.full_name`*::
+
--
type: keyword

example: Albert Einstein

User's full name, if available.


--

*`user.email`*::
+
--
type: keyword

User email address.


--

*`user.hash`*::
+
--
type: keyword

Unique user hash to correlate information for a user in anonymized form.
Useful if `user.id` or `user.name` contain confidential information and cannot be used.


--

*`user.group`*::
+
--
type: keyword

Group the user is a part of. This field can contain a list of groups, if necessary.


--

[float]
== user_agent fields

The user_agent fields normally come from a browser request. They often show up in web service logs coming from the parsed user agent string.



*`user_agent.original`*::
+
--
type: keyword

example: Mozilla/5.0 (iPhone; CPU iPhone OS 12_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1

Unparsed version of the user_agent.


Field is not indexed.

--

*`user_agent.name`*::
+
--
type: keyword

example: Safari

Name of the user agent.


--

*`user_agent.version`*::
+
--
type: keyword

example: 12.0

Version of the user agent.


--

*`user_agent.device.name`*::
+
--
type: keyword

example: iPhone

Name of the device.


--

[float]
== os fields

The OS fields contain information about the operating system.



*`user_agent.os.platform`*::
+
--
type: keyword

example: darwin

Operating system platform (such centos, ubuntu, windows).


--

*`user_agent.os.name`*::
+
--
type: keyword

example: Mac OS X

Operating system name.


--

*`user_agent.os.family`*::
+
--
type: keyword

example: debian

OS family (such as redhat, debian, freebsd, windows).


--

*`user_agent.os.version`*::
+
--
type: keyword

example: 10.12.6-rc2

Operating system version as a raw string.


--

*`user_agent.os.kernel`*::
+
--
type: keyword

example: 4.4.0-112-generic

Operating system kernel version as a raw string.


--

*`beat.name`*::
+
--
type: alias

alias to: agent.type

--

*`beat.hostname`*::
+
--
type: alias

alias to: agent.hostname

--

*`agent.hostname`*::
+
--
type: keyword

Hostname of the agent.


--

*`user_agent.patch`*::
+
--
type: keyword

Patch version of the user agent.


--

*`user_agent.minor`*::
+
--
type: keyword

Minor version of the user agent.


--

*`user_agent.major`*::
+
--
type: keyword

Major version of the user agent.


--

*`user_agent.device`*::
+
--
type: keyword

Name of the physical device.


--

*`user_agent.os.major`*::
+
--
type: long

Major version of the operating system.


--

*`user_agent.os.minor`*::
+
--
type: long

Minor version of the operating system.


--

*`url.hostname`*::
+
--
type: keyword

Hostname of the request, such as ""elastic.co"".


--

[[exported-fields-eventlog]]
== Event log record fields

Contains data from a Windows event log record.



*`activity_id`*::
+
--
type: keyword

required: False

A globally unique identifier that identifies the current activity. The events that are published with this identifier are part of the same activity.


--

*`computer_name`*::
+
--
type: keyword

required: True

The name of the computer that generated the record. When using Windows event forwarding, this name can differ from the `beat.hostname`.


--

*`event_data`*::
+
--
type: object

required: False

The event-specific data. This field is mutually exclusive with `user_data`. If you are capturing event data on versions prior to Windows Vista, the parameters in `event_data` are named `param1`, `param2`, and so on, because event log parameters are unnamed in earlier versions of Windows.


--

*`event_id`*::
+
--
type: long

required: True

The event identifier. The value is specific to the source of the event.


--

*`keywords`*::
+
--
type: keyword

required: False

The keywords are used to classify an event.


--

*`log_name`*::
+
--
type: keyword

required: True

The name of the event log from which this record was read. This value is one of the names from the `event_logs` collection in the configuration.


--

*`level`*::
+
--
type: keyword

required: False

The level of the event. There are five levels of events that can be logged: Success, Information, Warning, Error, Audit Success, and Audit Failure.


--

*`message_error`*::
+
--
type: keyword

required: False

The error that occurred while reading and formatting the message from the log.


--

*`record_number`*::
+
--
type: keyword

required: True

The record number of the event log record. The first record written to an event log is record number 1, and other records are numbered sequentially. If the record number reaches the maximum value (2^32^ for the Event Logging API and 2^64^ for the Windows Event Log API), the next record number will be 0.


--

*`related_activity_id`*::
+
--
type: keyword

required: False

A globally unique identifier that identifies the activity to which control was transferred to. The related events would then have this identifier as their `activity_id` identifier.


--

*`opcode`*::
+
--
type: keyword

required: False

The opcode defined in the event. Task and opcode are typically used to identify the location in the application from where the event was logged.


--

*`provider_guid`*::
+
--
type: keyword

required: False

A globally unique identifier that identifies the provider that logged the event.


--

*`process_id`*::
+
--
type: long

required: False

The process_id identifies the process that generated the event.


--

*`source_name`*::
+
--
type: keyword

required: True

The source of the event log record (the application or service that logged the record).


--

*`task`*::
+
--
type: keyword

required: False

The task defined in the event. Task and opcode are typically used to identify the location in the application from where the event was logged. The category used by the Event Logging API (on pre Windows Vista operating systems) is written to this field.


--

*`thread_id`*::
+
--
type: long

required: False

The thread_id identifies the thread that generated the event.


--

*`user_data`*::
+
--
type: object

required: False

The event specific data. This field is mutually exclusive with `event_data`.


--

*`user.identifier`*::
+
--
type: keyword

example: S-1-5-21-3541430928-2051711210-1391384369-1001

required: False

The Windows security identifier (SID) of the account associated with this event.

If Winlogbeat cannot resolve the SID to a name, then the `user.name`, `user.domain`, and `user.type` fields will be omitted from the event. If you discover Winlogbeat not resolving SIDs, review the log for clues as to what the problem may be.


--

*`user.domain`*::
+
--
type: keyword

required: False

The domain that the account associated with this event is a member of.


--

*`user.type`*::
+
--
type: keyword

required: False

The type of account associated with this event.


--

*`version`*::
+
--
type: long

required: False

The version number of the event's definition.

--

*`xml`*::
+
--
type: text

required: False

The raw XML representation of the event obtained from Windows. This field is only available on operating systems supporting the Windows Event Log API (Microsoft Windows Vista and newer). This field is not included by default and must be enabled by setting `include_xml: true` as a configuration option for an individual event log.

The XML representation of the event is useful for troubleshooting purposes. The data in the fields reported by Winlogbeat can be compared to the data in the XML to diagnose problems.


--

[[exported-fields-host-processor]]
== Host fields

Info collected for the host machine.


[[exported-fields-kubernetes-processor]]
== Kubernetes fields

Kubernetes metadata added by the kubernetes processor




*`kubernetes.pod.name`*::
+
--
type: keyword

Kubernetes pod name


--

*`kubernetes.pod.uid`*::
+
--
type: keyword

Kubernetes Pod UID


--

*`kubernetes.namespace`*::
+
--
type: keyword

Kubernetes namespace


--

*`kubernetes.node.name`*::
+
--
type: keyword

Kubernetes node name


--

*`kubernetes.labels`*::
+
--
type: object

Kubernetes labels map


--

*`kubernetes.annotations`*::
+
--
type: object

Kubernetes annotations map


--

*`kubernetes.container.name`*::
+
--
type: keyword

Kubernetes container name


--

*`kubernetes.container.image`*::
+
--
type: keyword

Kubernetes container image


--

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


#include ""video_cp_auto_cc_11_sc.h""

#include ""video_cp_auto_cc_11.h""

#include ""axi_clock_converter.h""

#include <map>
#include <string>





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

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

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

  // initialize socket stubs

}

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

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

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

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

    // S_AXI' transactor ports

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

    // S_AXI' transactor sockets

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

  // configure 'M_AXI' transactor

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

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

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

    // M_AXI' transactor ports

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

    // M_AXI' transactor sockets

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

}

#endif // XILINX_SIMULATOR




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

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

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

  // initialize socket stubs

}

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

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

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

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

    // S_AXI' transactor ports

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

    // S_AXI' transactor sockets

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

  // configure 'M_AXI' transactor

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

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

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

    // M_AXI' transactor ports

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

    // M_AXI' transactor sockets

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

}

#endif // XM_SYSTEMC




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

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

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

  // initialize socket stubs

}

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

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

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

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

    // S_AXI' transactor ports

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

    // S_AXI' transactor sockets

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

  // configure 'M_AXI' transactor

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

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

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

    // M_AXI' transactor ports

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

    // M_AXI' transactor sockets

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

}

#endif // RIVIERA




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

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

  // Instantiate Socket Stubs

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

    mp_S_AXI_transactor = new xtlm::xaximm_pin2xtlm_t<32,7,1,1,1,1,1,1>(""S_AXI_transactor"", S_AXI_transactor_param_props);
  mp_S_AXI_transactor->AWADDR(s_axi_awaddr);
  mp_S_AXI_transactor->AWPROT(s_axi_awprot);
  mp_S_AXI_transactor->AWVALID(s_axi_awvalid);
  mp_S_AXI_transactor->AWREADY(s_axi_awready);
  mp_S_AXI_transactor->WDATA(s_axi_wdata);
  mp_S_AXI_transactor->WSTRB(s_axi_wstrb);
  mp_S_AXI_transactor->WVALID(s_axi_wvalid);
  mp_S_AXI_transactor->WREADY(s_axi_wready);
  mp_S_AXI_transactor->BRESP(s_axi_bresp);
  mp_S_AXI_transactor->BVALID(s_axi_bvalid);
  mp_S_AXI_transactor->BREADY(s_axi_bready);
  mp_S_AXI_transactor->ARADDR(s_axi_araddr);
  mp_S_AXI_transactor->ARPROT(s_axi_arprot);
  mp_S_AXI_transactor->ARVALID(s_axi_arvalid);
  mp_S_AXI_transactor->ARREADY(s_axi_arready);
  mp_S_AXI_transactor->RDATA(s_axi_rdata);
  mp_S_AXI_transactor->RRESP(s_axi_rresp);
  mp_S_AXI_transactor->RVALID(s_axi_rvalid);
  mp_S_AXI_transactor->RREADY(s_axi_rready);
  mp_S_AXI_transactor->CLK(s_axi_aclk);
  m_S_AXI_transactor_rst_signal.write(1);
  mp_S_AXI_transactor->RST(m_S_AXI_transactor_rst_signal);
  // configure M_AXI_transactor
    xsc::common_cpp::properties M_AXI_transactor_param_props;
    M_AXI_transactor_param_props.addLong(""DATA_WIDTH"", ""32"");
    M_AXI_transactor_param_props.addLong(""FREQ_HZ"", ""142857132"");
    M_AXI_transactor_param_props.addLong(""ID_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""ADDR_WIDTH"", ""7"");
    M_AXI_transactor_param_props.addLong(""AWUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""ARUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""WUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""RUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""BUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_BURST"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_LOCK"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_PROT"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_CACHE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_QOS"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_REGION"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_WSTRB"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_BRESP"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_RRESP"", ""1"");
    M_AXI_transactor_param_props.addLong(""SUPPORTS_NARROW_BURST"", ""0"");
    M_AXI_transactor_param_props.addLong(""NUM_READ_OUTSTANDING"", ""2"");
    M_AXI_transactor_param_props.addLong(""NUM_WRITE_OUTSTANDING"", ""2"");
    M_AXI_transactor_param_props.addLong(""MAX_BURST_LENGTH"", ""1"");
    M_AXI_transactor_param_props.addLong(""NUM_READ_THREADS"", ""1"");
    M_AXI_transactor_param_props.addLong(""NUM_WRITE_THREADS"", ""1"");
    M_AXI_transactor_param_props.addLong(""RUSER_BITS_PER_BYTE"", ""0"");
    M_AXI_transactor_param_props.addLong(""WUSER_BITS_PER_BYTE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_SIZE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_RESET"", ""0"");
    M_AXI_transactor_param_props.addFloat(""PHASE"", ""0.000"");
    M_AXI_transactor_param_props.addString(""PROTOCOL"", ""AXI4LITE"");
    M_AXI_transactor_param_props.addString(""READ_WRITE_MODE"", ""READ_WRITE"");
    M_AXI_transactor_param_props.addString(""CLK_DOMAIN"", ""video_cp_ps7_0_0_FCLK_CLK1"");

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

  // initialize transactors stubs
  S_AXI_transactor_target_wr_socket_stub = nullptr;
  S_AXI_transactor_target_rd_socket_stub = nullptr;
  M_AXI_transactor_initiator_wr_socket_stub = nullptr;
  M_AXI_transactor_initiator_rd_socket_stub = nullptr;

}

void video_cp_auto_cc_11::before_end_of_elaboration()
{
  // configure 'S_AXI' transactor
  if (xsc::utils::xsc_sim_manager::getInstanceParameterInt(""video_cp_auto_cc_11"", ""S_AXI_TLM_MODE"") != 1)
  {
    mp_impl->S_TARGET_rd_socket->bind(*(mp_S_AXI_transactor->rd_socket));
    mp_impl->S_TARGET_wr_socket->bind(*(mp_S_AXI_transactor->wr_socket));
  
  }
  else
  {
    S_AXI_transactor_target_wr_socket_stub = new xtlm::xtlm_aximm_target_stub(""wr_socket"",0);
    S_AXI_transactor_target_wr_socket_stub->bind(*(mp_S_AXI_transactor->wr_socket));
    S_AXI_transactor_target_rd_socket_stub = new xtlm::xtlm_aximm_target_stub(""rd_socket"",0);
    S_AXI_transactor_target_rd_socket_stub->bind(*(mp_S_AXI_transactor->rd_socket));
    mp_S_AXI_transactor->disable_transactor();
  }

  // configure 'M_AXI' transactor
  if (xsc::utils::xsc_sim_manager::getInstanceParameterInt(""video_cp_auto_cc_11"", ""M_AXI_TLM_MODE"") != 1)
  {
    mp_impl->M_INITIATOR_rd_socket->bind(*(mp_M_AXI_transactor->rd_socket));
    mp_impl->M_INITIATOR_wr_socket->bind(*(mp_M_AXI_transactor->wr_socket));
  
  }
  else
  {
    M_AXI_transactor_initiator_wr_socket_stub = new xtlm::xtlm_aximm_initiator_stub(""wr_socket"",0);
    M_AXI_transactor_initiator_wr_socket_stub->bind(*(mp_M_AXI_transactor->wr_socket));
    M_AXI_transactor_initiator_rd_socket_stub = new xtlm::xtlm_aximm_initiator_stub(""rd_socket"",0);
    M_AXI_transactor_initiator_rd_socket_stub->bind(*(mp_M_AXI_transactor->rd_socket));
    mp_M_AXI_transactor->disable_transactor();
  }

}

#endif // VCSSYSTEMC




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

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

  // Instantiate Socket Stubs

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

    mp_S_AXI_transactor = new xtlm::xaximm_pin2xtlm_t<32,7,1,1,1,1,1,1>(""S_AXI_transactor"", S_AXI_transactor_param_props);
  mp_S_AXI_transactor->AWADDR(s_axi_awaddr);
  mp_S_AXI_transactor->AWPROT(s_axi_awprot);
  mp_S_AXI_transactor->AWVALID(s_axi_awvalid);
  mp_S_AXI_transactor->AWREADY(s_axi_awready);
  mp_S_AXI_transactor->WDATA(s_axi_wdata);
  mp_S_AXI_transactor->WSTRB(s_axi_wstrb);
  mp_S_AXI_transactor->WVALID(s_axi_wvalid);
  mp_S_AXI_transactor->WREADY(s_axi_wready);
  mp_S_AXI_transactor->BRESP(s_axi_bresp);
  mp_S_AXI_transactor->BVALID(s_axi_bvalid);
  mp_S_AXI_transactor->BREADY(s_axi_bready);
  mp_S_AXI_transactor->ARADDR(s_axi_araddr);
  mp_S_AXI_transactor->ARPROT(s_axi_arprot);
  mp_S_AXI_transactor->ARVALID(s_axi_arvalid);
  mp_S_AXI_transactor->ARREADY(s_axi_arready);
  mp_S_AXI_transactor->RDATA(s_axi_rdata);
  mp_S_AXI_transactor->RRESP(s_axi_rresp);
  mp_S_AXI_transactor->RVALID(s_axi_rvalid);
  mp_S_AXI_transactor->RREADY(s_axi_rready);
  mp_S_AXI_transactor->CLK(s_axi_aclk);
  m_S_AXI_transactor_rst_signal.write(1);
  mp_S_AXI_transactor->RST(m_S_AXI_transactor_rst_signal);
  // configure M_AXI_transactor
    xsc::common_cpp::properties M_AXI_transactor_param_props;
    M_AXI_transactor_param_props.addLong(""DATA_WIDTH"", ""32"");
    M_AXI_transactor_param_props.addLong(""FREQ_HZ"", ""142857132"");
    M_AXI_transactor_param_props.addLong(""ID_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""ADDR_WIDTH"", ""7"");
    M_AXI_transactor_param_props.addLong(""AWUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""ARUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""WUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""RUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""BUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_BURST"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_LOCK"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_PROT"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_CACHE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_QOS"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_REGION"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_WSTRB"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_BRESP"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_RRESP"", ""1"");
    M_AXI_transactor_param_props.addLong(""SUPPORTS_NARROW_BURST"", ""0"");
    M_AXI_transactor_param_props.addLong(""NUM_READ_OUTSTANDING"", ""2"");
    M_AXI_transactor_param_props.addLong(""NUM_WRITE_OUTSTANDING"", ""2"");
    M_AXI_transactor_param_props.addLong(""MAX_BURST_LENGTH"", ""1"");
    M_AXI_transactor_param_props.addLong(""NUM_READ_THREADS"", ""1"");
    M_AXI_transactor_param_props.addLong(""NUM_WRITE_THREADS"", ""1"");
    M_AXI_transactor_param_props.addLong(""RUSER_BITS_PER_BYTE"", ""0"");
    M_AXI_transactor_param_props.addLong(""WUSER_BITS_PER_BYTE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_SIZE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_RESET"", ""0"");
    M_AXI_transactor_param_props.addFloat(""PHASE"", ""0.000"");
    M_AXI_transactor_param_props.addString(""PROTOCOL"", ""AXI4LITE"");
    M_AXI_transactor_param_props.addString(""READ_WRITE_MODE"", ""READ_WRITE"");
    M_AXI_transactor_param_props.addString(""CLK_DOMAIN"", ""video_cp_ps7_0_0_FCLK_CLK1"");

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

  // initialize transactors stubs
  S_AXI_transactor_target_wr_socket_stub = nullptr;
  S_AXI_transactor_target_rd_socket_stub = nullptr;
  M_AXI_transactor_initiator_wr_socket_stub = nullptr;
  M_AXI_transactor_initiator_rd_socket_stub = nullptr;

}

void video_cp_auto_cc_11::before_end_of_elaboration()
{
  // configure 'S_AXI' transactor
  if (xsc::utils::xsc_sim_manager::getInstanceParameterInt(""video_cp_auto_cc_11"", ""S_AXI_TLM_MODE"") != 1)
  {
    mp_impl->S_TARGET_rd_socket->bind(*(mp_S_AXI_transactor->rd_socket));
    mp_impl->S_TARGET_wr_socket->bind(*(mp_S_AXI_transactor->wr_socket));
  
  }
  else
  {
    S_AXI_transactor_target_wr_socket_stub = new xtlm::xtlm_aximm_target_stub(""wr_socket"",0);
    S_AXI_transactor_target_wr_socket_stub->bind(*(mp_S_AXI_transactor->wr_socket));
    S_AXI_transactor_target_rd_socket_stub = new xtlm::xtlm_aximm_target_stub(""rd_socket"",0);
    S_AXI_transactor_target_rd_socket_stub->bind(*(mp_S_AXI_transactor->rd_socket));
    mp_S_AXI_transactor->disable_transactor();
  }

  // configure 'M_AXI' transactor
  if (xsc::utils::xsc_sim_manager::getInstanceParameterInt(""video_cp_auto_cc_11"", ""M_AXI_TLM_MODE"") != 1)
  {
    mp_impl->M_INITIATOR_rd_socket->bind(*(mp_M_AXI_transactor->rd_socket));
    mp_impl->M_INITIATOR_wr_socket->bind(*(mp_M_AXI_transactor->wr_socket));
  
  }
  else
  {
    M_AXI_transactor_initiator_wr_socket_stub = new xtlm::xtlm_aximm_initiator_stub(""wr_socket"",0);
    M_AXI_transactor_initiator_wr_socket_stub->bind(*(mp_M_AXI_transactor->wr_socket));
    M_AXI_transactor_initiator_rd_socket_stub = new xtlm::xtlm_aximm_initiator_stub(""rd_socket"",0);
    M_AXI_transactor_initiator_rd_socket_stub->bind(*(mp_M_AXI_transactor->rd_socket));
    mp_M_AXI_transactor->disable_transactor();
  }

}

#endif // MTI_SYSTEMC




video_cp_auto_cc_11::~video_cp_auto_cc_11()
{
  delete mp_S_AXI_transactor;

  delete mp_M_AXI_transactor;

}

#ifdef MTI_SYSTEMC
SC_MODULE_EXPORT(video_cp_auto_cc_11);
#endif

#ifdef XM_SYSTEMC
XMSC_MODULE_EXPORT(video_cp_auto_cc_11);
#endif

#ifdef RIVIERA
SC_MODULE_EXPORT(video_cp_auto_cc_11);
#endif

",16332,True,4802.785959797224,median
"// Copyright 2017 the original author or authors.
//
// Licensed under the Apache License, Version 2.0 (the ""License"");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an ""AS IS"" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

[[native_software]]
= Building native software


[CAUTION]
====
The https://blog.gradle.org/state-and-future-of-the-gradle-software-model[software model] is being retired and the plugins mentioned in this chapter will eventually be deprecated and removed.
We recommend new projects looking to build C++ applications and libraries use the newer <<building_cpp_projects.adoc#,replacement plugins>>.
====

The native software plugins add support for building native software components, such as executables or shared libraries, from code written in C++, C and other languages. While many excellent build tools exist for this space of software development, Gradle offers developers its trademark power and flexibility together with dependency management practices more traditionally found in the JVM development space.

The native software plugins make use of the Gradle software model.


[[sec:native_features]]
== Features

The native software plugins provide:

* Support for building native libraries and applications on Windows, Linux, macOS and other platforms.
* Support for several source languages.
* Support for building different variants of the same software, for different architectures, operating systems, or for any purpose.
* Incremental parallel compilation, precompiled headers.
* Dependency management between native software components.
* Unit test execution.
* Generate Visual studio solution and project files.
* Deep integration with various tool chain, including discovery of installed tool chains.


[[sec:supported_languages]]
== Supported languages

The following source languages are currently supported:

* C
* C++
* Objective-C
* Objective-C++
* Assembly
* Windows resources


[[native-binaries:tool-chain-support]]
== Tool chain support

Gradle offers the ability to execute the same build using different tool chains. When you build a native binary, Gradle will attempt to locate a tool chain installed on your machine that can build the binary. You can fine tune exactly how this works, see <<#native_binaries:tool_chain,Tool chain support>> for details.

The following tool chains are supported:

[%header%autowidth,compact]
|===
| Operating System | Tool Chain | Notes

| Linux
| http://gcc.gnu.org/[GCC]
|

| Linux
| http://clang.llvm.org[Clang]
|

| macOS
| XCode
| Uses the Clang tool chain bundled with XCode.

| Windows
| https://visualstudio.microsoft.com/[Visual C++]
| Windows XP and later, Visual C++ 2010/2012/2013/2015/2017/2019.

| Windows
| http://gcc.gnu.org/[GCC] with http://cygwin.com[Cygwin 32 and Cygwin 64]
| Windows XP and later.

| Windows
| http://gcc.gnu.org/[GCC] with http://www.mingw.org/[MinGW] and https://mingw-w64.org/doku.php[MinGW64]
| Windows XP and later.
|===

The following tool chains are unofficially supported. They generally work fine, but are not tested continuously:

[%header%autowidth,compact]
|===
| Operating System | Tool Chain | Notes

| macOS
| http://gcc.gnu.org/[GCC] from Macports
|

| macOS
| http://clang.llvm.org[Clang] from Macports
|

| UNIX-like
| http://gcc.gnu.org/[GCC]
|

| UNIX-like
| http://clang.llvm.org[Clang]
|
|===


[[sec:tool_chain_installation]]
== Tool chain installation


[NOTE]
====

Note that if you are using GCC then you currently need to install support for C+\\+, even if you are not building from C++ source. This restriction will be removed in a future Gradle version.

====

To build native software, you will need to have a compatible tool chain installed:


[[sec:windows]]
=== Windows

To build on Windows, install a compatible version of Visual Studio. The native plugins will discover the Visual Studio installations and select the latest version. There is no need to mess around with environment variables or batch scripts. This works fine from a Cygwin shell or the Windows command-line.

Alternatively, you can install Cygwin with GCC or MinGW. Clang is currently not supported.

[[sec:macOS]]
=== macOS

To build on macOS, you should install XCode. The native plugins will discover the XCode installation using the system PATH.

The native plugins also work with GCC and Clang bundled with Macports. To use one of the Macports tool chains, you will need to make the tool chain the default using the `port select` command and add Macports to the system PATH.

[[sec:linux]]
=== Linux

To build on Linux, install a compatible version of GCC or Clang. The native plugins will discover GCC or Clang using the system PATH.

[[sec:native_software_model]]
== Native software model

The native software model builds on the base Gradle software model.

To build native software using Gradle, your project should define one or more _native components_. Each component represents either an executable or a library that Gradle should build. A project can define any number of components. Gradle does not define any components by default.

For each component, Gradle defines a _source set_ for each language that the component can be built from. A source set is essentially just a set of source directories containing source files. For example, when you apply the `c` plugin and define a library called `helloworld`, Gradle will define, by default, a source set containing the C source files in the `src/helloworld/c` directory. It will use these source files to build the `helloworld` library. This is described in more detail below.

For each component, Gradle defines one or more _binaries_ as output. To build a binary, Gradle will take the source files defined for the component, compile them as appropriate for the source language, and link the result into a binary file. For an executable component, Gradle can produce executable binary files. For a library component, Gradle can produce both static and shared library binary files. For example, when you define a library called `helloworld` and build on Linux, Gradle will, by default, produce `libhelloworld.so` and `libhelloworld.a` binaries.

In many cases, more than one binary can be produced for a component. These binaries may vary based on the tool chain used to build, the compiler/linker flags supplied, the dependencies provided, or additional source files provided. Each native binary produced for a component is referred to as a _variant_. Binary variants are discussed in detail below.

[[sec:parallel_compilation]]
== Parallel Compilation

Gradle uses the single build worker pool to concurrently compile and link native components, by default. No special configuration is required to enable concurrent building.

By default, the worker pool size is determined by the number of available processors on the build machine (as reported to the build JVM). To explicitly set the number of workers use the `--max-workers` command-line option or `org.gradle.workers.max` system property. There is generally no need to change this setting from its default.

The build worker pool is shared across all build tasks. This means that when using <<multi_project_configuration_and_execution.adoc#sec:parallel_execution,parallel project execution>>, the maximum number of concurrent individual compilation operations does not increase. For example, if the build machine has 4 processing cores and 10 projects are compiling in parallel, Gradle will only use 4 total workers, not 40.

[[sec:building_a_library]]
== Building a library

To build either a static or shared native library, you define a library component in the `components` container. The following sample defines a library called `hello`:

=== Example: Defining a library component

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/c/groovy/build.gradle[tag=libraries]
----

A library component is represented using link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec]. Each library component can produce at least one shared library binary (link:{javadocPath}/org/gradle/nativeplatform/SharedLibraryBinarySpec.html[SharedLibraryBinarySpec]) and at least one static library binary (link:{javadocPath}/org/gradle/nativeplatform/StaticLibraryBinarySpec.html[StaticLibraryBinarySpec]).

[[sec:building_an_executable]]
== Building an executable

To build a native executable, you define an executable component in the `components` container. The following sample defines an executable called `main`:

=== Example: Defining executable components

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/c/groovy/build.gradle[tag=executables]
----

An executable component is represented using link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableSpec.html[NativeExecutableSpec]. Each executable component can produce at least one executable binary (link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableBinarySpec.html[NativeExecutableBinarySpec]).

For each component defined, Gradle adds a link:{javadocPath}/org/gradle/language/base/FunctionalSourceSet.html[FunctionalSourceSet] with the same name. Each of these functional source sets will contain a language-specific source set for each of the languages supported by the project.

[[sec:dependents]]
== Assembling or building dependents

Sometimes, you may need to _assemble_ (compile and link) or _build_ (compile, link and test) a component or binary and its _dependents_ (things that depend upon the component or binary). The native software model provides tasks that enable this capability. First, the _dependent components_ report gives insight about the relationships between each component. Second, the _build and assemble dependents_ tasks allow you to assemble or build a component and its dependents in one step.

In the following example, the build file defines `OpenSSL` as a dependency of `libUtil` and `libUtil` as a dependency of `LinuxApp` and `WindowsApp`. Test suites are treated similarly. Dependents can be thought of as reverse dependencies.

.Dependent Components Example
image::nativeDependents.png[]

[NOTE]
====
By following the dependencies backwards, you can see `LinuxApp` and `WindowsApp` are _dependents_ of `libUtil`. When `libUtil` is changed, Gradle will need to recompile or relink `LinuxApp` and `WindowsApp`.
====


When you _assemble_ dependents of a component, the component and all of its dependents are compiled and linked, including any test suite binaries. Gradle's up-to-date checks are used to only compile or link if something has changed. For instance, if you have changed source files in a way that do not affect the headers of your project, Gradle will be able to skip compilation for dependent components and only need to re-link with the new library. Tests are not run when assembling a component.

When you _build_ dependents of a component, the component and all of its dependent binaries are compiled, linked _and checked_. Checking components means running any <<#sec:check_tasks,check task>> including executing any test suites, so tests _are_ run when building a component.

In the following sections, we will demonstrate the usage of the `assembleDependents\\*`, `buildDependents*` and `dependentComponents` tasks with a sample build that contains a CUnit test suite. The build script for the sample is the following:

=== Example: Sample build

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/cunit/groovy/build.gradle[tag=terse-example]
----



[[sec:dependents_report]]
=== Dependent components report

Gradle provides a report that you can run from the command-line that shows a graph of components in your project and components that depend upon them. The following is an example of running `gradle dependentComponents` on the sample project:

=== Example: Dependent components report

.Output of **`gradle dependentComponents`**
----
> gradle dependentComponents
include::{snippetsPath}/native-binaries/cunit/tests/dependentComponentsReport.out[]
----

[NOTE]
====
See link:{groovyDslPath}/org.gradle.api.reporting.dependents.DependentComponentsReport.html[DependentComponentsReport] API documentation for more details.
====

By default, non-buildable binaries and test suites are hidden from the report. The `dependentComponents` task provides options that allow you to see all dependents by using the `--all` option:

=== Example: Dependent components report

.Output of **`gradle dependentComponents --all`**
----
> gradle dependentComponents --all
include::{snippetsPath}/native-binaries/cunit/tests/dependentComponentsReportAll.out[]
----

Here is the corresponding report for the `operators` component, showing dependents of all its binaries:

=== Example: Report of components that depends on the operators component

.Output of **`gradle dependentComponents --component operators`**
----
> gradle dependentComponents --component operators
include::{snippetsPath}/native-binaries/cunit/tests/assembleDependentComponentsReport.out[]
----

Here is the corresponding report for the `operators` component, showing dependents of all its binaries, including test suites:

=== Example: Report of components that depends on the operators component, including test suites

.Output of **`gradle dependentComponents --test-suites --component operators`**
----
> gradle dependentComponents --test-suites --component operators
include::{snippetsPath}/native-binaries/cunit/tests/buildDependentComponentsReport.out[]
----


[[sec:assemble_dependents]]
=== Assembling dependents

For each link:{javadocPath}/org/gradle/nativeplatform/NativeBinarySpec.html[NativeBinarySpec], Gradle will create a task named `assembleDependents__${component.name}${binary.variant}__` that _assembles_ (compile and link) the binary and all of its dependent binaries.

For each link:{javadocPath}/org/gradle/nativeplatform/NativeComponentSpec.html[NativeComponentSpec], Gradle will create a task named `assembleDependents__${component.name}__` that _assembles_ all the binaries of the component and all of their dependent binaries.

For example, to assemble the dependents of the ""passing"" flavor of the ""static"" library binary of the ""operators"" component, you would run the `assembleDependentsOperatorsPassingStaticLibrary` task:

=== Example: Assemble components that depends on the passing/static binary of the operators component

.Output of **`gradle assembleDependentsOperatorsPassingStaticLibrary --max-workers=1`**
----
> gradle assembleDependentsOperatorsPassingStaticLibrary --max-workers=1
include::{snippetsPath}/native-binaries/cunit/tests/assembleDependentComponents.out[]
----

In the output above, the targeted binary gets assembled as well as the test suite binary that depends on it.

You can also assemble _all_ of the dependents of a component (i.e. of all its binaries/variants) using the corresponding component task, e.g. `assembleDependentsOperators`. This is useful if you have many combinations of build types, flavors and platforms and want to assemble all of them.

[[sec:build_dependents]]
=== Building dependents

For each link:{javadocPath}/org/gradle/nativeplatform/NativeBinarySpec.html[NativeBinarySpec], Gradle will create a task named `buildDependents__${component.name}${binary.variant}__` that _builds_ (compile, link and check) the binary and all of its dependent binaries.

For each link:{javadocPath}/org/gradle/nativeplatform/NativeComponentSpec.html[NativeComponentSpec], Gradle will create a task named `buildDependents__${component.name}__` that _builds_ all the binaries of the component and all of their dependent binaries.

For example, to build the dependents of the ""passing"" flavor of the ""static"" library binary of the ""operators"" component, you would run the `buildDependentsOperatorsPassingStaticLibrary` task:

=== Example: Build components that depends on the passing/static binary of the operators component

.Output of **`gradle buildDependentsOperatorsPassingStaticLibrary --max-workers=1`**
----
> gradle buildDependentsOperatorsPassingStaticLibrary --max-workers=1
include::{snippetsPath}/native-binaries/cunit/tests/buildDependentComponents.out[]
----

In the output above, the targeted binary as well as the test suite binary that depends on it are built and the test suite has run.

You can also build _all_ of the dependents of a component (i.e. of all its binaries/variants) using the corresponding component task, e.g. `buildDependentsOperators`.

[[sec:native_tasks]]
== Tasks

For each link:{javadocPath}/org/gradle/nativeplatform/NativeBinarySpec.html[NativeBinarySpec] that can be produced by a build, a single _lifecycle task_ is constructed that can be used to create that binary, together with a set of other tasks that do the actual work of compiling, linking or assembling the binary.


`__${component.name}__Executable`::
  Component Type;;
    link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableSpec.html[NativeExecutableSpec]
  Native Binary Type;;
    link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableBinarySpec.html[NativeExecutableBinarySpec]
  Location of created binary;;
    `__${project.buildDir}__/exe/__${component.name}__/__${component.name}__`

`__${component.name}__SharedLibrary`::
  Component Type;;
    link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec]
  Native Binary Type;;
    link:{javadocPath}/org/gradle/nativeplatform/SharedLibraryBinarySpec.html[SharedLibraryBinarySpec]
  Location of created binary;;
    `__${project.buildDir}__/libs/__${component.name}__/shared/lib__${component.name}__.so`

`__${component.name}__StaticLibrary`::
  Component Type;;
    link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec]
  Native Binary Type;;
    link:{javadocPath}/org/gradle/nativeplatform/StaticLibraryBinarySpec.html[StaticLibraryBinarySpec]
  Location of created binary;;
    `__${project.buildDir}__/libs/__${component.name}__/static/__${component.name}__.a`


[[sec:check_tasks]]
=== Check tasks

For each link:{javadocPath}/org/gradle/nativeplatform/NativeBinarySpec.html[NativeBinarySpec] that can be produced by a build, a single _check task_ is constructed that can be used to assemble and check that binary.

`check__${component.name}__Executable`::
  Component Type;;
    link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableSpec.html[NativeExecutableSpec]
  Native Binary Type;;
    link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableBinarySpec.html[NativeExecutableBinarySpec]

`check__${component.name}__SharedLibrary`::
  Component Type;;
    link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec]
  Native Binary Type;;
    link:{javadocPath}/org/gradle/nativeplatform/SharedLibraryBinarySpec.html[SharedLibraryBinarySpec]

`check__${component.name}__StaticLibrary`::
  Component Type;;
    link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec]
  Native Binary Type;;
    link:{javadocPath}/org/gradle/nativeplatform/SharedLibraryBinarySpec.html[SharedLibraryBinarySpec]

The built-in `check` task depends on all the _check tasks_ for binaries in the project. Without either <<#native_binaries:cunit,CUnit>> or <<#native_binaries:google_test,GoogleTest>> plugins, the binary check task only depends on the _lifecycle task_ that assembles the binary, see <<#sec:native_tasks,Native tasks>>.

When the <<#native_binaries:cunit,CUnit>> or <<#native_binaries:google_test,GoogleTest>> plugins are applied, the task that executes the test suites for a component are automatically wired to the appropriate _check task_.

You can also add custom check tasks as follows:

=== Example: Adding a custom check task

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/custom-check/groovy/build.gradle[tag=custom-check]
----



Now, running `check` or any of the _check tasks_ for the `hello` binaries will run the custom check task:

=== Example: Running checks for a given binary

.Output of **`gradle checkHelloSharedLibrary`**
----
> gradle checkHelloSharedLibrary
include::{snippetsPath}/native-binaries/custom-check/tests/nativeComponentCustomCheckOutput.out[]
----


[[sec:working_with_shared_libraries]]
=== Working with shared libraries

For each executable binary produced, the `cpp` plugin provides an `install${binary.name}` task, which creates a development install of the executable, along with the shared libraries it requires. This allows you to run the executable without needing to install the shared libraries in their final locations.

[[sec:finding_out_more_about_your_project]]
== Finding out more about your project

Gradle provides a report that you can run from the command-line that shows some details about the components and binaries that your project produces. To use this report, just run `gradle components`. Below is an example of running this report for one of the sample projects:

=== Example: The components report

.Output of **`gradle components`**
----
> gradle components
include::{snippetsPath}/native-binaries/cpp/tests/nativeComponentReport.out[]
----


[[native_binaries:languages]]
== Language support

Presently, Gradle supports building native software from any combination of source languages listed below. A native binary project will contain one or more named `FunctionalSourceSet` instances (e.g. 'main', 'test', etc), each of which can contain ``LanguageSourceSet``s containing source files, one for each language.

* C
* C++
* Objective-C
* Objective-C++
* Assembly
* Windows resources


[[sec:cpp_sources]]
=== C++ sources

C++ language support is provided by means of the `'cpp'` plugin.

=== Example: The 'cpp' plugin

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/cpp/groovy/build.gradle[tag=apply-plugin]
----

$$C++$$ sources to be included in a native binary are provided via a link:{groovyDslPath}/org.gradle.language.cpp.CppSourceSet.html[CppSourceSet], which defines a set of C++ source files and optionally a set of exported header files (for a library). By default, for any named component the link:{groovyDslPath}/org.gradle.language.cpp.CppSourceSet.html[CppSourceSet] contains `.cpp` source files in `src/${name}/cpp`, and header files in `src/${name}/headers`.

While the `cpp` plugin defines these default locations for each link:{groovyDslPath}/org.gradle.language.cpp.CppSourceSet.html[CppSourceSet], it is possible to extend or override these defaults to allow for a different project layout.

=== Example: C++ source set

[source.multi-language-sample,groovy,indent=0]
.build.gradle
----
include::{snippetsPath}/native-binaries/custom-layout/groovy/build.gradle[tag=cpp-sources]
----

For a library named 'main', header files in `src/main/headers` are considered the ""public"" or ""exported"" headers. Header files that should not be exported should be placed inside the `src/main/cpp` directory (though be aware that such header files should always be referenced in a manner relative to the file including them).

[[sec:c_sources]]
=== C sources

C language support is provided by means of the `'c'` plugin.

=== Example: The 'c' plugin

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/c/groovy/build.gradle[tag=apply-plugin]
----

C sources to be included in a native binary are provided via a link:{groovyDslPath}/org.gradle.language.c.CSourceSet.html[CSourceSet], which defines a set of C source files and optionally a set of exported header files (for a library). By default, for any named component the link:{groovyDslPath}/org.gradle.language.c.CSourceSet.html[CSourceSet] contains `.c` source files in `src/${name}/c`, and header files in `src/${name}/headers`.

While the `c` plugin defines these default locations for each link:{groovyDslPath}/org.gradle.language.c.CSourceSet.html[CSourceSet], it is possible to extend or override these defaults to allow for a different project layout.

=== Example: C source set

[source.multi-language-sample,groovy,indent=0]
.build.gradle
----
include::{snippetsPath}/native-binaries/custom-layout/groovy/build.gradle[tag=c-sources]
----

For a library named 'main', header files in `src/main/headers` are considered the ""public"" or ""exported"" headers. Header files that should not be exported should be placed inside the `src/main/c` directory (though be aware that such header files should always be referenced in a manner relative to the file including them).

[[sec:assembler_sources]]
=== Assembler sources

Assembly language support is provided by means of the `'assembler'` plugin.

=== Example: The 'assembler' plugin

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/assembler/groovy/build.gradle[tag=apply-plugin]
----

Assembler sources to be included in a native binary are provided via a link:{groovyDslPath}/org.gradle.language.assembler.AssemblerSourceSet.html[AssemblerSourceSet], which defines a set of Assembler source files. By default, for any named component the link:{groovyDslPath}/org.gradle.language.assembler.AssemblerSourceSet.html[AssemblerSourceSet] contains `.s` source files under `src/${name}/asm`.

[[sec:objectivec_sources]]
=== Objective-C sources

Objective-C language support is provided by means of the `'objective-c'` plugin.

=== Example: The 'objective-c' plugin

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/objective-c/groovy/build.gradle[tag=apply-plugin]
----

Objective-C sources to be included in a native binary are provided via a link:{groovyDslPath}/org.gradle.language.objectivec.ObjectiveCSourceSet.html[ObjectiveCSourceSet], which defines a set of Objective-C source files. By default, for any named component the link:{groovyDslPath}/org.gradle.language.objectivec.ObjectiveCSourceSet.html[ObjectiveCSourceSet] contains `.m` source files under `src/${name}/objectiveC`.

[[sec:objectivecpp_sources]]
=== Objective-C++ sources

Objective-C++ language support is provided by means of the `'objective-cpp'` plugin.

=== Example: The 'objective-cpp' plugin

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/objective-cpp/groovy/build.gradle[tag=apply-plugin]
----

Objective-C$$++$$ sources to be included in a native binary are provided via a link:{groovyDslPath}/org.gradle.language.objectivecpp.ObjectiveCppSourceSet.html[ObjectiveCppSourceSet], which defines a set of Objective-C++ source files. By default, for any named component the link:{groovyDslPath}/org.gradle.language.objectivecpp.ObjectiveCppSourceSet.html[ObjectiveCppSourceSet] contains `.mm` source files under `src/${name}/objectiveCpp`.

[[sec:configuring_the_compiler_assembler_and_linker]]
== Configuring the compiler, assembler and linker

Each binary to be produced is associated with a set of compiler and linker settings, which include command-line arguments as well as macro definitions. These settings can be applied to all binaries, an individual binary, or selectively to a group of binaries based on some criteria.

=== Example: Settings that apply to all binaries

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/cpp/groovy/build.gradle[tag=all-binaries]
----

Each binary is associated with a particular link:{javadocPath}/org/gradle/nativeplatform/toolchain/NativeToolChain.html[NativeToolChain], allowing settings to be targeted based on this value.

It is easy to apply settings to all binaries of a particular type:

=== Example: Settings that apply to all shared libraries

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/c/groovy/build.gradle[tag=all-shared-libraries]
----

Furthermore, it is possible to specify settings that apply to all binaries produced for a particular `executable` or `library` component:

=== Example: Settings that apply to all binaries produced for the 'main' executable component

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/assembler/groovy/build.gradle[tag=assembler-args]
----

The example above will apply the supplied configuration to all `executable` binaries built.

Similarly, settings can be specified to target binaries for a component that are of a particular type: e.g. all shared libraries for the main library component.

=== Example: Settings that apply only to shared libraries produced for the 'main' library component

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/cpp-lib/groovy/build.gradle[tag=args]
----


[[native_binaries:windows-resources]]
== Windows Resources

When using the link:{groovyDslPath}/org.gradle.nativeplatform.toolchain.VisualCpp.html[VisualCpp] tool chain, Gradle is able to compile Window Resource (`rc`) files and link them into a native binary. This functionality is provided by the `'windows-resources'` plugin.

=== Example: The 'windows-resources' plugin

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/windows-resources/groovy/build.gradle[tag=apply-plugin]
----

Windows resources to be included in a native binary are provided via a link:{groovyDslPath}/org.gradle.language.rc.WindowsResourceSet.html[WindowsResourceSet], which defines a set of Windows Resource source files. By default, for any named component the link:{groovyDslPath}/org.gradle.language.rc.WindowsResourceSet.html[WindowsResourceSet] contains `.rc` source files under `src/${name}/rc`.

As with other source types, you can configure the location of the windows resources that should be included in the binary.

=== Example: Configuring the location of Windows resource sources

[source.multi-language-sample,groovy,indent=0]
.build-resource-only-dll.gradle
----
include::{snippetsPath}/native-binaries/windows-resources/groovy/build-resource-only-dll.gradle[tag=windows-resource-set]
----

You are able to construct a resource-only library by providing Windows Resource sources with no other language sources, and configure the linker as appropriate:

=== Example: Building a resource-only dll

[source.multi-language-sample,groovy]
.build-resource-only-dll.gradle
----
include::{snippetsPath}/native-binaries/windows-resources/groovy/build-resource-only-dll.gradle[tag=resource-only-library]
----

The example above also demonstrates the mechanism of passing extra command-line arguments to the resource compiler. The `rcCompiler` extension is of type link:{javadocPath}/org/gradle/nativeplatform/PreprocessingTool.html[PreprocessingTool].

[[sec:library_dependencies]]
== Library Dependencies

Dependencies for native components are binary libraries that export header files. The header files are used during compilation, with the compiled binary dependency being used during linking and execution. Header files should be organized into subdirectories to prevent clashes of commonly named headers. For instance, if your `mylib` project has a `logging.h` header, it will make it less likely the wrong header is used if you include it as `""mylib/logging.h""` instead of `""logging.h""`.


[[sec:dependencies_within_the_same_project]]
=== Dependencies within the same project

A set of sources may depend on header files provided by another binary component within the same project. A common example is a native executable component that uses functions provided by a separate native library component.

Such a library dependency can be added to a source set associated with the `executable` component:

=== Example: Providing a library dependency to the source set

[source.multi-language-sample,groovy,indent=0]
.build.gradle
----
include::{snippetsPath}/native-binaries/cpp/groovy/build.gradle[tag=source-library]
----

Alternatively, a library dependency can be provided directly to the `NativeExecutableBinarySpec` for the `executable`.

=== Example: Providing a library dependency to the binary

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/custom-layout/groovy/build.gradle[tag=binary-library]
----


[[sec:project_dependencies]]
=== Project Dependencies

For a component produced in a different Gradle project, the notation is similar.

=== Example: Declaring project dependencies

[source.multi-language-sample,groovy]
.lib/build.gradle
----
include::{snippetsPath}/native-binaries/multi-project/groovy/lib/build.gradle[]
----
[source.multi-language-sample,groovy]
.exe/build.gradle
----
include::{snippetsPath}/native-binaries/multi-project/groovy/exe/build.gradle[]
----


[[native_binaries:preCompiledHeaders]]
== Precompiled Headers

Precompiled headers are a performance optimization that reduces the cost of compiling widely used headers multiple times. This feature _precompiles_ a header such that the compiled object file can be reused when compiling each source file rather than recompiling the header each time. This support is available for C, C+\\+, Objective-C, and Objective-C++ builds.

To configure a precompiled header, first a header file needs to be defined that includes all of the headers that should be precompiled. It must be specified as the first included header in every source file where the precompiled header should be used. It is assumed that this header file, and any headers it contains, make use of header guards so that they can be included in an idempotent manner. If header guards are not used in a header file, it is possible the header could be compiled more than once and could potentially lead to a broken build.

=== Example: Creating a precompiled header file

[source.multi-language-sample,c]
.src/hello/headers/pch.h
----
include::{snippetsPath}/native-binaries/pre-compiled-headers/groovy/src/hello/headers/pch.h[]
----

=== Example: Including a precompiled header file in a source file

[source.multi-language-sample,cpp]
.src/hello/cpp/hello.cpp
----
include::{snippetsPath}/native-binaries/pre-compiled-headers/groovy/src/hello/cpp/hello.cpp[]
----

Precompiled headers are specified on a source set. Only one precompiled header file can be specified on a given source set and will be applied to all source files that declare it as the first include. If a source files does not include this header file as the first header, the file will be compiled in the normal manner (without making use of the precompiled header object file). The string provided should be the same as that which is used in the ""#include"" directive in the source files.

=== Example: Configuring a precompiled header

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/pre-compiled-headers/groovy/build.gradle[tag=libraries]
----

A precompiled header must be included in the same way for all files that use it. Usually, this means the header file should exist in the source set ""headers"" directory or in a directory included on the compiler include path.

[[native_binaries:variants]]
== Native Binary Variants

For each executable or library defined, Gradle is able to build a number of different native binary variants. Examples of different variants include debug vs release binaries, 32-bit vs 64-bit binaries, and binaries produced with different custom preprocessor flags.

Binaries produced by Gradle can be differentiated on <<#native_binaries:build_type,build type>>, <<#native_binaries:platform,platform>>, and <<#native_binaries:flavor,flavor>>. For each of these 'variant dimensions', it is possible to specify a set of available values as well as target each component at one, some or all of these. For example, a plugin may define a range of support platforms, but you may choose to only target Windows-x86 for a particular component.


[[native_binaries:build_type]]
=== Build types

A `build type` determines various non-functional aspects of a binary, such as whether debug information is included, or what optimisation level the binary is compiled with. Typical build types are 'debug' and 'release', but a project is free to define any set of build types.

=== Example: Defining build types

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/variants/groovy/build.gradle[tag=build-types]
----

If no build types are defined in a project, then a single, default build type called 'debug' is added.

For a build type, a Gradle project will typically define a set of compiler/linker flags per tool chain.

=== Example: Configuring debug binaries

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/variants/groovy/build.gradle[tag=build-type-config]
----

[NOTE]
====
At this stage, it is completely up to the build script to configure the relevant compiler/linker flags for each build type. Future versions of Gradle will automatically include the appropriate debug flags for any 'debug' build type, and may be aware of various levels of optimisation as well.
====


[[native_binaries:platform]]
=== Platform

An executable or library can be built to run on different operating systems and cpu architectures, with a variant being produced for each platform. Gradle defines each OS/architecture combination as a link:{groovyDslPath}/org.gradle.nativeplatform.platform.NativePlatform.html[NativePlatform], and a project may define any number of platforms. If no platforms are defined in a project, then a single, default platform 'current' is added.

[NOTE]
====
Presently, a `Platform` consists of a defined operating system and architecture. As we continue to develop the native binary support in Gradle, the concept of Platform will be extended to include things like C-runtime version, Windows SDK, ABI, etc. Sophisticated builds may use the extensibility of Gradle to apply additional attributes to each platform, which can then be queried to specify particular includes, preprocessor macros or compiler arguments for a native binary.
====

=== Example: Defining platforms

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/variants/groovy/build.gradle[tag=platforms]
----

For a given variant, Gradle will attempt to find a link:{javadocPath}/org/gradle/nativeplatform/toolchain/NativeToolChain.html[NativeToolChain] that is able to build for the target platform. Available tool chains are searched in the order defined. See the <<#native_binaries:tool_chain,tool chains>> section below for more details.

[[native_binaries:flavor]]
=== Flavor

Each component can have a set of named `flavors`, and a separate binary variant can be produced for each flavor. While the `build type` and `target platform` variant dimensions have a defined meaning in Gradle, each project is free to define any number of flavors and apply meaning to them in any way.

An example of component flavors might differentiate between 'demo', 'paid' and 'enterprise' editions of the component, where the same set of sources is used to produce binaries with different functions.

=== Example: Defining flavors

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/flavors/groovy/build.gradle[tag=flavors]
----

In the example above, a library is defined with a 'english' and 'french' flavor. When compiling the 'french' variant, a separate macro is defined which leads to a different binary being produced.

If no flavor is defined for a component, then a single default flavor named 'default' is used.

[[sec:selecting_the_build_types_platforms_and_flavors_for_a_component]]
=== Selecting the build types, platforms and flavors for a component

For a default component, Gradle will attempt to create a native binary variant for each and every combination of `buildType` and `flavor` defined for the project. It is possible to override this on a per-component basis, by specifying the set of `targetBuildTypes` and/or `targetFlavors`. By default, Gradle will build for the default platform, see <<#native_binaries:platform,above>>, unless specified explicitly on a per-component basis by specifying a set of `targetPlatforms`.

=== Example: Targeting a component at particular platforms

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/variants/groovy/build.gradle[tag=target-platforms]
----

Here you can see that the link:{groovyDslPath}/org.gradle.nativeplatform.TargetedNativeComponent.html#org.gradle.nativeplatform.TargetedNativeComponent:targetPlatform(java.lang.String)[TargetedNativeComponent.targetPlatform(java.lang.String)] method is used to specify a platform that the `NativeExecutableSpec` named `main` should be built for.

A similar mechanism exists for selecting link:{groovyDslPath}/org.gradle.nativeplatform.TargetedNativeComponent.html#org.gradle.nativeplatform.TargetedNativeComponent:targetBuildTypes(java.lang.String++[]++)[TargetedNativeComponent.targetBuildTypes(java.lang.String...)] and link:{groovyDslPath}/org.gradle.nativeplatform.TargetedNativeComponent.html#org.gradle.nativeplatform.TargetedNativeComponent:targetFlavors(java.lang.String++[]++)[TargetedNativeComponent.targetFlavors(java.lang.String...)].

[[sec:building_all_possible_variants]]
=== Building all possible variants

When a set of build types, target platforms, and flavors is defined for a component, a link:{javadocPath}/org/gradle/nativeplatform/NativeBinarySpec.html[NativeBinarySpec] model element is created for every possible combination of these. However, in many cases it is not possible to build a particular variant, perhaps because no tool chain is available to build for a particular platform.

If a binary variant cannot be built for any reason, then the link:{javadocPath}/org/gradle/nativeplatform/NativeBinarySpec.html[NativeBinarySpec] associated with that variant will not be `buildable`. It is possible to use this property to create a task to generate all possible variants on a particular machine.

=== Example: Building all possible variants

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/tool-chains/groovy/build.gradle[tag=buildable]
----


[[native_binaries:tool_chain]]
== Tool chains

A single build may utilize different tool chains to build variants for different platforms. To this end, the core 'native-binary' plugins will attempt to locate and make available supported tool chains. However, the set of tool chains for a project may also be explicitly defined, allowing additional cross-compilers to be configured as well as allowing the install directories to be specified.


[[sec:defining_tool_chains]]
=== Defining tool chains

The supported tool chain types are:

* link:{groovyDslPath}/org.gradle.nativeplatform.toolchain.Gcc.html[Gcc]
* link:{groovyDslPath}/org.gradle.nativeplatform.toolchain.Clang.html[Clang]
* link:{groovyDslPath}/org.gradle.nativeplatform.toolchain.VisualCpp.html[VisualCpp]

=== Example: Defining tool chains

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/tool-chains/groovy/build.gradle[tag=toolChains]
----

Each tool chain implementation allows for a certain degree of configuration (see the API documentation for more details).

[[sec:using_tool_chains]]
=== Using tool chains

It is not necessary or possible to specify the tool chain that should be used to build. For a given variant, Gradle will attempt to locate a link:{javadocPath}/org/gradle/nativeplatform/toolchain/NativeToolChain.html[NativeToolChain] that is able to build for the target platform. Available tool chains are searched in the order defined.

[NOTE]
====
When a platform does not define an architecture or operating system, the default target of the tool chain is assumed. So if a platform does not define a value for `operatingSystem`, Gradle will find the first available tool chain that can build for the specified `architecture`.
====

The core Gradle tool chains are able to target the following architectures out of the box. In each case, the tool chain will target the current operating system. See the next section for information on cross-compiling for other operating systems.

[cols=""a,a"", options=""header""]
|===
| Tool Chain
| Architectures

| GCC
| x86, x86_64

| Clang
| x86, x86_64

| Visual C++
| x86, x86_64, ia-64
|===

So for GCC running on linux, the supported target platforms are 'linux/x86' and 'linux/x86_64'. For GCC running on Windows via Cygwin, platforms 'windows/x86' and 'windows/x86_64' are supported. (The Cygwin POSIX runtime is not yet modelled as part of the platform, but will be in the future.)

If no target platforms are defined for a project, then all binaries are built to target a default platform named 'current'. This default platform does not specify any `architecture` or `operatingSystem` value, hence using the default values of the first available tool chain.

Gradle provides a _hook_ that allows the build author to control the exact set of arguments passed to a tool chain executable. This enables the build author to work around any limitations in Gradle, or assumptions that Gradle makes. The arguments hook should be seen as a 'last-resort' mechanism, with preference given to truly modelling the underlying domain.

=== Example: Reconfigure tool arguments

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/tool-chains/groovy/build.gradle[tag=withArguments]
----


[[sec:crosscompiling_with_gcc]]
=== Cross-compiling with GCC

Cross-compiling is possible with the link:{groovyDslPath}/org.gradle.nativeplatform.toolchain.Gcc.html[Gcc] and link:{groovyDslPath}/org.gradle.nativeplatform.toolchain.Clang.html[Clang] tool chains, by adding support for additional target platforms. This is done by specifying a target platform for a toolchain. For each target platform a custom configuration can be specified.

=== Example: Defining target platforms

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/target-platforms/groovy/build.gradle[tag=targetplatforms]
----


[[native_binaries:visual_studio]]
== Visual Studio IDE integration

Gradle has the ability to generate Visual Studio project and solution files for the native components defined in your build. This ability is added by the `visual-studio` plugin. For a multi-project build, all projects with native components (and the root project) should have this plugin applied.

When the `visual-studio` plugin is applied to the root project, a task named `visualStudio` is created, which will generate a Visual Studio solution file containing all components in the build. This solution will include a Visual Studio project for each component, as well as configuring each component to build using Gradle.

A task named `openVisualStudio` is also created by the `visual-studio` plugin when the project is the root project. This task generates the Visual Studio solution and then opens the solution in Visual Studio. This means you can simply run `gradlew openVisualStudio` from the root project to generate and open the Visual Studio solution in one convenient step.

The content of the generated visual studio files can be modified via API hooks, provided by the `visualStudio` extension. Take a look at the 'visual-studio' sample, or see link:{groovyDslPath}/org.gradle.ide.visualstudio.VisualStudioExtension.html#org.gradle.ide.visualstudio.VisualStudioExtension:projects[VisualStudioExtension.getProjects()] and link:{groovyDslPath}/org.gradle.ide.visualstudio.VisualStudioRootExtension.html#org.gradle.ide.visualstudio.VisualStudioRootExtension:solution[VisualStudioRootExtension.getSolution()] in the API documentation for more details.

[[native_binaries:cunit]]
== CUnit support

The Gradle `cunit` plugin provides support for compiling and executing CUnit tests in your native-binary project. For each link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableSpec.html[NativeExecutableSpec] and link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec] defined in your project, Gradle will create a matching link:{groovyDslPath}/org.gradle.nativeplatform.test.cunit.CUnitTestSuiteSpec.html[CUnitTestSuiteSpec] component, named `${component.name}Test`.


[[sec:cunit_sources]]
=== CUnit sources

Gradle will create a link:{groovyDslPath}/org.gradle.language.c.CSourceSet.html[CSourceSet] named 'cunit' for each link:{groovyDslPath}/org.gradle.nativeplatform.test.cunit.CUnitTestSuiteSpec.html[CUnitTestSuiteSpec] component in the project. This source set should contain the cunit test files for the component under test. Source files can be located in the conventional location (`src/${component.name}Test/cunit`) or can be configured like any other source set.

Gradle initialises the CUnit test registry and executes the tests, utilising some generated CUnit launcher sources. Gradle will expect and call a function with the signature `void gradle_cunit_register()` that you can use to configure the actual CUnit suites and tests to execute.

=== Example: Registering CUnit tests

[source.multi-language-sample,c]
.suite_operators.c
----
include::{snippetsPath}/native-binaries/cunit/groovy/src/operatorsTest/c/suite_operators.c[]
----

[NOTE]
====
Due to this mechanism, your CUnit sources may not contain a `main` method since this will clash with the method provided by Gradle.
====


[[sec:building_cunit_executables]]
=== Building CUnit executables

A link:{groovyDslPath}/org.gradle.nativeplatform.test.cunit.CUnitTestSuiteSpec.html[CUnitTestSuiteSpec] component has an associated link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableSpec.html[NativeExecutableSpec] or link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec] component. For each link:{javadocPath}/org/gradle/nativeplatform/NativeBinarySpec.html[NativeBinarySpec] configured for the main component, a matching link:{groovyDslPath}/org.gradle.nativeplatform.test.cunit.CUnitTestSuiteBinarySpec.html[CUnitTestSuiteBinarySpec] will be configured on the test suite component. These test suite binaries can be configured in a similar way to any other binary instance:

=== Example: Configuring CUnit tests

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/cunit/groovy/build.gradle[tag=configure-test-binary]
----

[NOTE]
====
Both the CUnit sources provided by your project and the generated launcher require the core CUnit headers and libraries. Presently, this library dependency must be provided by your project for each link:{groovyDslPath}/org.gradle.nativeplatform.test.cunit.CUnitTestSuiteBinarySpec.html[CUnitTestSuiteBinarySpec].
====


[[sec:running_cunit_tests]]
=== Running CUnit tests

For each link:{groovyDslPath}/org.gradle.nativeplatform.test.cunit.CUnitTestSuiteBinarySpec.html[CUnitTestSuiteBinarySpec], Gradle will create a task to execute this binary, which will run all of the registered CUnit tests. Test results will be found in the `__${build.dir}__/test-results` directory.

=== Example: Running CUnit tests

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/cunit/groovy/build.gradle[tag=complete-example]
----

.Output of `gradle -q runOperatorsTestFailingCUnitExe`
----
> gradle -q runOperatorsTestFailingCUnitExe
include::{snippetsPath}/native-binaries/cunit/tests/completeCUnitExample.out[]
----



[NOTE]
====

The current support for CUnit is quite rudimentary. Plans for future integration include:

* Allow tests to be declared with Javadoc-style annotations.
* Improved HTML reporting, similar to that available for JUnit.
* Real-time feedback for test execution.
* Support for additional test frameworks.

====


[[native_binaries:google_test]]
== GoogleTest support

The Gradle `google-test` plugin provides support for compiling and executing GoogleTest tests in your native-binary project. For each link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableSpec.html[NativeExecutableSpec] and link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec] defined in your project, Gradle will create a matching link:{groovyDslPath}/org.gradle.nativeplatform.test.googletest.GoogleTestTestSuiteSpec.html[GoogleTestTestSuiteSpec] component, named `${component.name}Test`.


[[sec:googletest_sources]]
=== GoogleTest sources

Gradle will create a link:{groovyDslPath}/org.gradle.language.cpp.CppSourceSet.html[CppSourceSet] named 'cpp' for each link:{groovyDslPath}/org.gradle.nativeplatform.test.googletest.GoogleTestTestSuiteSpec.html[GoogleTestTestSuiteSpec] component in the project. This source set should contain the GoogleTest test files for the component under test. Source files can be located in the conventional location (`src/${component.name}Test/cpp`) or can be configured like any other source set.

[[sec:building_googletest_executables]]
=== Building GoogleTest executables

A link:{groovyDslPath}/org.gradle.nativeplatform.test.googletest.GoogleTestTestSuiteSpec.html[GoogleTestTestSuiteSpec] component has an associated link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableSpec.html[NativeExecutableSpec] or link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec] component. For each link:{javadocPath}/org/gradle/nativeplatform/NativeBinarySpec.html[NativeBinarySpec] configured for the main component, a matching link:{groovyDslPath}/org.gradle.nativeplatform.test.googletest.GoogleTestTestSuiteBinarySpec.html[GoogleTestTestSuiteBinarySpec] will be configured on the test suite component. These test suite binaries can be configured in a similar way to any other binary instance:

=== Example: Registering GoogleTest tests

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/google-test/groovy/build.gradle[tag=configure-test-binary]
----


[NOTE]
====
The GoogleTest sources provided by your project require the core GoogleTest headers and libraries. Presently, this library dependency must be provided by your project for each link:{groovyDslPath}/org.gradle.nativeplatform.test.googletest.GoogleTestTestSuiteBinarySpec.html[GoogleTestTestSuiteBinarySpec].
====


[[sec:running_googletest_tests]]
=== Running GoogleTest tests

For each link:{groovyDslPath}/org.gradle.nativeplatform.test.googletest.GoogleTestTestSuiteBinarySpec.html[GoogleTestTestSuiteBinarySpec], Gradle will create a task to execute this binary, which will run all of the registered GoogleTest tests. Test results will be found in the `__${build.dir}__/test-results` directory.
[NOTE]
====

The current support for GoogleTest is quite rudimentary. Plans for future integration include:

* Improved HTML reporting, similar to that available for JUnit.
* Real-time feedback for test execution.
* Support for additional test frameworks.

====
",12172,False,2319.5383084087757,median
"// Automatically generated by 'openshift-apidocs-gen'. Do not edit.
:_content-type: ASSEMBLY
[id=""machineset-machine-openshift-io-v1beta1""]
= MachineSet [machine.openshift.io/v1beta1]
ifdef::product-title[]
include::modules/common-attributes.adoc[]
endif::[]

toc::[]


Description::
+
--
MachineSet ensures that a specified number of machines replicas are running at any given time.
--

Type::
  `object`



== Specification

[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `apiVersion`
| `string`
| APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources

| `kind`
| `string`
| Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds

| `metadata`
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta_v2[`ObjectMeta_v2`]
| Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata

| `spec`
| `object`
| MachineSetSpec defines the desired state of MachineSet

| `status`
| `object`
| MachineSetStatus defines the observed state of MachineSet

|===
=== .spec
Description::
+
--
MachineSetSpec defines the desired state of MachineSet
--

Type::
  `object`

Required::
  - `selector`



[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `deletePolicy`
| `string`
| DeletePolicy defines the policy used to identify nodes to delete when downscaling. Defaults to ""Random"".  Valid values are ""Random, ""Newest"", ""Oldest""

| `minReadySeconds`
| `integer`
| MinReadySeconds is the minimum number of seconds for which a newly created machine should be ready. Defaults to 0 (machine will be considered available as soon as it is ready)

| `replicas`
| `integer`
| Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1.

| `selector`
| `object`
| Selector is a label query over machines that should match the replica count. Label keys and values that must match in order to be controlled by this MachineSet. It must match the machine template's labels. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors

| `template`
| `object`
| Template is the object that describes the machine that will be created if insufficient replicas are detected.

|===
=== .spec.selector
Description::
+
--
Selector is a label query over machines that should match the replica count. Label keys and values that must match in order to be controlled by this MachineSet. It must match the machine template's labels. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors
--

Type::
  `object`




[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `matchExpressions`
| `array`
| matchExpressions is a list of label selector requirements. The requirements are ANDed.

| `matchExpressions[]`
| `object`
| A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.

| `matchLabels`
| `object (string)`
| matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is ""key"", the operator is ""In"", and the values array contains only ""value"". The requirements are ANDed.

|===
=== .spec.selector.matchExpressions
Description::
+
--
matchExpressions is a list of label selector requirements. The requirements are ANDed.
--

Type::
  `array`




=== .spec.selector.matchExpressions[]
Description::
+
--
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
--

Type::
  `object`

Required::
  - `key`
  - `operator`



[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `key`
| `string`
| key is the label key that the selector applies to.

| `operator`
| `string`
| operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.

| `values`
| `array (string)`
| values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.

|===
=== .spec.template
Description::
+
--
Template is the object that describes the machine that will be created if insufficient replicas are detected.
--

Type::
  `object`




[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `metadata`
| `object`
| Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata

| `spec`
| `object`
| Specification of the desired behavior of the machine. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status

|===
=== .spec.template.metadata
Description::
+
--
Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
--

Type::
  `object`




[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `annotations`
| `object (string)`
| Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations

| `generateName`
| `string`
| GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server. 
 If this field is specified and the generated name exists, the server will NOT return a 409 - instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, and the client should retry (optionally after the time indicated in the Retry-After header). 
 Applied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency

| `labels`
| `object (string)`
| Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels

| `name`
| `string`
| Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names

| `namespace`
| `string`
| Namespace defines the space within each name must be unique. An empty namespace is equivalent to the ""default"" namespace, but ""default"" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty. 
 Must be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces

| `ownerReferences`
| `array`
| List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.

| `ownerReferences[]`
| `object`
| OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.

|===
=== .spec.template.metadata.ownerReferences
Description::
+
--
List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.
--

Type::
  `array`




=== .spec.template.metadata.ownerReferences[]
Description::
+
--
OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.
--

Type::
  `object`

Required::
  - `apiVersion`
  - `kind`
  - `name`
  - `uid`



[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `apiVersion`
| `string`
| API version of the referent.

| `blockOwnerDeletion`
| `boolean`
| If true, AND if the owner has the ""foregroundDeletion"" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. Defaults to false. To set this field, a user needs ""delete"" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.

| `controller`
| `boolean`
| If true, this reference points to the managing controller.

| `kind`
| `string`
| Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds

| `name`
| `string`
| Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names

| `uid`
| `string`
| UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids

|===
=== .spec.template.spec
Description::
+
--
Specification of the desired behavior of the machine. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
--

Type::
  `object`




[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `metadata`
| `object`
| ObjectMeta will autopopulate the Node created. Use this to indicate what labels, annotations, name prefix, etc., should be used when creating the Node.

| `providerID`
| `string`
| ProviderID is the identification ID of the machine provided by the provider. This field must match the provider ID as seen on the node object corresponding to this machine. This field is required by higher level consumers of cluster-api. Example use case is cluster autoscaler with cluster-api as provider. Clean-up logic in the autoscaler compares machines to nodes to find out machines at provider which could not get registered as Kubernetes nodes. With cluster-api as a generic out-of-tree provider for autoscaler, this field is required by autoscaler to be able to have a provider view of the list of machines. Another list of nodes is queried from the k8s apiserver and then a comparison is done to find out unregistered machines and are marked for delete. This field will be set by the actuators and consumed by higher level entities like autoscaler that will be interfacing with cluster-api as generic provider.

| `providerSpec`
| `object`
| ProviderSpec details Provider-specific configuration to use during node creation.

| `taints`
| `array`
| The list of the taints to be applied to the corresponding Node in additive manner. This list will not overwrite any other taints added to the Node on an ongoing basis by other entities. These taints should be actively reconciled e.g. if you ask the machine controller to apply a taint and then manually remove the taint the machine controller will put it back) but not have the machine controller remove any taints

| `taints[]`
| `object`
| The node this Taint is attached to has the ""effect"" on any pod that does not tolerate the Taint.

|===
=== .spec.template.spec.metadata
Description::
+
--
ObjectMeta will autopopulate the Node created. Use this to indicate what labels, annotations, name prefix, etc., should be used when creating the Node.
--

Type::
  `object`




[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `annotations`
| `object (string)`
| Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations

| `generateName`
| `string`
| GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server. 
 If this field is specified and the generated name exists, the server will NOT return a 409 - instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, and the client should retry (optionally after the time indicated in the Retry-After header). 
 Applied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency

| `labels`
| `object (string)`
| Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels

| `name`
| `string`
| Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names

| `namespace`
| `string`
| Namespace defines the space within each name must be unique. An empty namespace is equivalent to the ""default"" namespace, but ""default"" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty. 
 Must be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces

| `ownerReferences`
| `array`
| List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.

| `ownerReferences[]`
| `object`
| OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.

|===
=== .spec.template.spec.metadata.ownerReferences
Description::
+
--
List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.
--

Type::
  `array`




=== .spec.template.spec.metadata.ownerReferences[]
Description::
+
--
OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.
--

Type::
  `object`

Required::
  - `apiVersion`
  - `kind`
  - `name`
  - `uid`



[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `apiVersion`
| `string`
| API version of the referent.

| `blockOwnerDeletion`
| `boolean`
| If true, AND if the owner has the ""foregroundDeletion"" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. Defaults to false. To set this field, a user needs ""delete"" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.

| `controller`
| `boolean`
| If true, this reference points to the managing controller.

| `kind`
| `string`
| Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds

| `name`
| `string`
| Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names

| `uid`
| `string`
| UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids

|===
=== .spec.template.spec.providerSpec
Description::
+
--
ProviderSpec details Provider-specific configuration to use during node creation.
--

Type::
  `object`




[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `value`
| ``
| Value is an inlined, serialized representation of the resource configuration. It is recommended that providers maintain their own versioned API types that should be serialized/deserialized from this field, akin to component config.

|===
=== .spec.template.spec.taints
Description::
+
--
The list of the taints to be applied to the corresponding Node in additive manner. This list will not overwrite any other taints added to the Node on an ongoing basis by other entities. These taints should be actively reconciled e.g. if you ask the machine controller to apply a taint and then manually remove the taint the machine controller will put it back) but not have the machine controller remove any taints
--

Type::
  `array`




=== .spec.template.spec.taints[]
Description::
+
--
The node this Taint is attached to has the ""effect"" on any pod that does not tolerate the Taint.
--

Type::
  `object`

Required::
  - `effect`
  - `key`



[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `effect`
| `string`
| Required. The effect of the taint on pods that do not tolerate the taint. Valid effects are NoSchedule, PreferNoSchedule and NoExecute.

| `key`
| `string`
| Required. The taint key to be applied to a node.

| `timeAdded`
| `string`
| TimeAdded represents the time at which the taint was added. It is only written for NoExecute taints.

| `value`
| `string`
| The taint value corresponding to the taint key.

|===
=== .status
Description::
+
--
MachineSetStatus defines the observed state of MachineSet
--

Type::
  `object`

Required::
  - `replicas`



[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `availableReplicas`
| `integer`
| The number of available replicas (ready for at least minReadySeconds) for this MachineSet.

| `errorMessage`
| `string`
| 

| `errorReason`
| `string`
| In the event that there is a terminal problem reconciling the replicas, both ErrorReason and ErrorMessage will be set. ErrorReason will be populated with a succinct value suitable for machine interpretation, while ErrorMessage will contain a more verbose string suitable for logging and human consumption. 
 These fields should not be set for transitive errors that a controller faces that are expected to be fixed automatically over time (like service outages), but instead indicate that something is fundamentally wrong with the MachineTemplate's spec or the configuration of the machine controller, and that manual intervention is required. Examples of terminal errors would be invalid combinations of settings in the spec, values that are unsupported by the machine controller, or the responsible machine controller itself being critically misconfigured. 
 Any transient errors that occur during the reconciliation of Machines can be added as events to the MachineSet object and/or logged in the controller's output.

| `fullyLabeledReplicas`
| `integer`
| The number of replicas that have labels matching the labels of the machine template of the MachineSet.

| `observedGeneration`
| `integer`
| ObservedGeneration reflects the generation of the most recently observed MachineSet.

| `readyReplicas`
| `integer`
| The number of ready replicas for this MachineSet. A machine is considered ready when the node has been created and is ""Ready"".

| `replicas`
| `integer`
| Replicas is the most recently observed number of replicas.

|===

== API endpoints

The following API endpoints are available:

* `/apis/machine.openshift.io/v1beta1/machinesets`
- `GET`: list objects of kind MachineSet
* `/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets`
- `DELETE`: delete collection of MachineSet
- `GET`: list objects of kind MachineSet
- `POST`: create a MachineSet
* `/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}`
- `DELETE`: delete a MachineSet
- `GET`: read the specified MachineSet
- `PATCH`: partially update the specified MachineSet
- `PUT`: replace the specified MachineSet
* `/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}/scale`
- `GET`: read scale of the specified MachineSet
- `PATCH`: partially update scale of the specified MachineSet
- `PUT`: replace scale of the specified MachineSet
* `/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}/status`
- `GET`: read status of the specified MachineSet
- `PATCH`: partially update status of the specified MachineSet
- `PUT`: replace status of the specified MachineSet


=== /apis/machine.openshift.io/v1beta1/machinesets


.Global query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `allowWatchBookmarks`
| `boolean`
| allowWatchBookmarks requests watch events with type &quot;BOOKMARK&quot;. Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server&#x27;s discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.
| `continue`
| `string`
| The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the &quot;next key&quot;.

This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
| `fieldSelector`
| `string`
| A selector to restrict the list of returned objects by their fields. Defaults to everything.
| `labelSelector`
| `string`
| A selector to restrict the list of returned objects by their labels. Defaults to everything.
| `limit`
| `integer`
| limit is a maximum number of responses to return for a list call. If more items exist, the server will set the &#x60;continue&#x60; field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
| `pretty`
| `string`
| If &#x27;true&#x27;, then the output is pretty printed.
| `resourceVersion`
| `string`
| resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `resourceVersionMatch`
| `string`
| resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `timeoutSeconds`
| `integer`
| Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
| `watch`
| `boolean`
| Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

HTTP method::
  `GET`

Description::
  list objects of kind MachineSet


.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../objects/index.adoc#io.openshift.machine.v1beta1.MachineSetList[`MachineSetList`] schema
| 401 - Unauthorized
| Empty
|===


=== /apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets

.Global path parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `namespace`
| `string`
| object name and auth scope, such as for teams and projects
|===

.Global query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `pretty`
| `string`
| If &#x27;true&#x27;, then the output is pretty printed.
|===

HTTP method::
  `DELETE`

Description::
  delete collection of MachineSet


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `allowWatchBookmarks`
| `boolean`
| allowWatchBookmarks requests watch events with type &quot;BOOKMARK&quot;. Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server&#x27;s discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.
| `continue`
| `string`
| The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the &quot;next key&quot;.

This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
| `fieldSelector`
| `string`
| A selector to restrict the list of returned objects by their fields. Defaults to everything.
| `labelSelector`
| `string`
| A selector to restrict the list of returned objects by their labels. Defaults to everything.
| `limit`
| `integer`
| limit is a maximum number of responses to return for a list call. If more items exist, the server will set the &#x60;continue&#x60; field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
| `resourceVersion`
| `string`
| resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `resourceVersionMatch`
| `string`
| resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `timeoutSeconds`
| `integer`
| Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
| `watch`
| `boolean`
| Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===


.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2[`Status_v2`] schema
| 401 - Unauthorized
| Empty
|===

HTTP method::
  `GET`

Description::
  list objects of kind MachineSet


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `allowWatchBookmarks`
| `boolean`
| allowWatchBookmarks requests watch events with type &quot;BOOKMARK&quot;. Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server&#x27;s discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.
| `continue`
| `string`
| The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the &quot;next key&quot;.

This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
| `fieldSelector`
| `string`
| A selector to restrict the list of returned objects by their fields. Defaults to everything.
| `labelSelector`
| `string`
| A selector to restrict the list of returned objects by their labels. Defaults to everything.
| `limit`
| `integer`
| limit is a maximum number of responses to return for a list call. If more items exist, the server will set the &#x60;continue&#x60; field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
| `resourceVersion`
| `string`
| resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `resourceVersionMatch`
| `string`
| resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `timeoutSeconds`
| `integer`
| Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
| `watch`
| `boolean`
| Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===


.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../objects/index.adoc#io.openshift.machine.v1beta1.MachineSetList[`MachineSetList`] schema
| 401 - Unauthorized
| Empty
|===

HTTP method::
  `POST`

Description::
  create a MachineSet


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `dryRun`
| `string`
| When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
| `fieldManager`
| `string`
| fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
|===

.Body parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `body`
| xref:../machine_apis/machineset-machine-openshift-io-v1beta1.adoc#machineset-machine-openshift-io-v1beta1[`MachineSet`] schema
| 
|===

.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../machine_apis/machineset-machine-openshift-io-v1beta1.adoc#machineset-machine-openshift-io-v1beta1[`MachineSet`] schema
| 201 - Created
| xref:../machine_apis/machineset-machine-openshift-io-v1beta1.adoc#machineset-machine-openshift-io-v1beta1[`MachineSet`] schema
| 202 - Accepted
| xref:../machine_apis/machineset-machine-openshift-io-v1beta1.adoc#machineset-machine-openshift-io-v1beta1[`MachineSet`] schema
| 401 - Unauthorized
| Empty
|===


=== /apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}

.Global path parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `name`
| `string`
| name of the MachineSet
| `namespace`
| `string`
| object name and auth scope, such as for teams and projects
|===

.Global query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `pretty`
| `string`
| If &#x27;true&#x27;, then the output is pretty printed.
|===

HTTP method::
  `DELETE`

Description::
  delete a MachineSet


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `dryRun`
| `string`
| When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
| `gracePeriodSeconds`
| `integer`
| The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
| `orphanDependents`
| `boolean`
| Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the &quot;orphan&quot; finalizer will be added to/removed from the object&#x27;s finalizers list. Either this field or PropagationPolicy may be set, but not both.
| `propagationPolicy`
| `string`
| Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: &#x27;Orphan&#x27; - orphan the dependents; &#x27;Background&#x27; - allow the garbage collector to delete the dependents in the background; &#x27;Foreground&#x27; - a cascading policy that deletes all dependents in the foreground.
|===

.Body parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `body`
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions_v2[`DeleteOptions_v2`] schema
| 
|===

.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2[`Status_v2`] schema
| 202 - Accepted
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2[`Status_v2`] schema
| 401 - Unauthorized
| Empty
|===

HTTP method::
  `GET`

Description::
  read the specified MachineSet


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `resourceVersion`
| `string`
| resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
|===


.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../machine_apis/machineset-machine-openshift-io-v1beta1.adoc#machineset-machine-openshift-io-v1beta1[`MachineSet`] schema
| 401 - Unauthorized
| Empty
|===

HTTP method::
  `PATCH`

Description::
  partially update the specified MachineSet


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `dryRun`
| `string`
| When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
| `fieldManager`
| `string`
| fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
|===

.Body parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `body`
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.Patch[`Patch`] schema
| 
|===

.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../machine_apis/machineset-machine-openshift-io-v1beta1.adoc#machineset-machine-openshift-io-v1beta1[`MachineSet`] schema
| 401 - Unauthorized
| Empty
|===

HTTP method::
  `PUT`

Description::
  replace the specified MachineSet


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `dryRun`
| `string`
| When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
| `fieldManager`
| `string`
| fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
|===

.Body parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `body`
| xref:../machine_apis/machineset-machine-openshift-io-v1beta1.adoc#machineset-machine-openshift-io-v1beta1[`MachineSet`] schema
| 
|===

.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../machine_apis/machineset-machine-openshift-io-v1beta1.adoc#machineset-machine-openshift-io-v1beta1[`MachineSet`] schema
| 201 - Created
| xref:../machine_apis/machineset-machine-openshift-io-v1beta1.adoc#machineset-machine-openshift-io-v1beta1[`MachineSet`] schema
| 401 - Unauthorized
| Empty
|===


=== /apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}/scale

.Global path parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `name`
| `string`
| name of the MachineSet
| `namespace`
| `string`
| object name and auth scope, such as for teams and projects
|===

.Global query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `pretty`
| `string`
| If &#x27;true&#x27;, then the output is pretty printed.
|===

HTTP method::
  `GET`

Description::
  read scale of the specified MachineSet


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `resourceVersion`
| `string`
| resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
|===


.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../objects/index.adoc#io.k8s.api.autoscaling.v1.Scale_v2[`Scale_v2`] schema
| 401 - Unauthorized
| Empty
|===

HTTP method::
  `PATCH`

Description::
  partially update scale of the specified MachineSet


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `dryRun`
| `string`
| When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
| `fieldManager`
| `string`
| fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
|===

.Body parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `body`
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.Patch[`Patch`] schema
| 
|===

.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../objects/index.adoc#io.k8s.api.autoscaling.v1.Scale_v2[`Scale_v2`] schema
| 401 - Unauthorized
| Empty
|===

HTTP method::
  `PUT`

Description::
  replace scale of the specified MachineSet


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `dryRun`
| `string`
| When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
| `fieldManager`
| `string`
| fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
|===

.Body parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `body`
| xref:../objects/index.adoc#io.k8s.api.autoscaling.v1.Scale_v2[`Scale_v2`] schema
| 
|===

.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../objects/index.adoc#io.k8s.api.autoscaling.v1.Scale_v2[`Scale_v2`] schema
| 201 - Created
| xref:../objects/index.adoc#io.k8s.api.autoscaling.v1.Scale_v2[`Scale_v2`] schema
| 401 - Unauthorized
| Empty
|===


=== /apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}/status

.Global path parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `name`
| `string`
| name of the MachineSet
| `namespace`
| `string`
| object name and auth scope, such as for teams and projects
|===

.Global query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `pretty`
| `string`
| If &#x27;true&#x27;, then the output is pretty printed.
|===

HTTP method::
  `GET`

Description::
  read status of the specified MachineSet


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `resourceVersion`
| `string`
| resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
|===


.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../machine_apis/machineset-machine-openshift-io-v1beta1.adoc#machineset-machine-openshift-io-v1beta1[`MachineSet`] schema
| 401 - Unauthorized
| Empty
|===

HTTP method::
  `PATCH`

Description::
  partially update status of the specified MachineSet


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `dryRun`
| `string`
| When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
| `fieldManager`
| `string`
| fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
|===

.Body parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `body`
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.Patch[`Patch`] schema
| 
|===

.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../machine_apis/machineset-machine-openshift-io-v1beta1.adoc#machineset-machine-openshift-io-v1beta1[`MachineSet`] schema
| 401 - Unauthorized
| Empty
|===

HTTP method::
  `PUT`

Description::
  replace status of the specified MachineSet


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `dryRun`
| `string`
| When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
| `fieldManager`
| `string`
| fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
|===

.Body parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `body`
| xref:../machine_apis/machineset-machine-openshift-io-v1beta1.adoc#machineset-machine-openshift-io-v1beta1[`MachineSet`] schema
| 
|===

.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../machine_apis/machineset-machine-openshift-io-v1beta1.adoc#machineset-machine-openshift-io-v1beta1[`MachineSet`] schema
| 201 - Created
| xref:../machine_apis/machineset-machine-openshift-io-v1beta1.adoc#machineset-machine-openshift-io-v1beta1[`MachineSet`] schema
| 401 - Unauthorized
| Empty
|===


",12197,False,2478.9994534466696,median
"#include <nano/lib/jsonconfig.hpp>
#include <nano/node/election.hpp>
#include <nano/test_common/system.hpp>
#include <nano/test_common/testutil.hpp>

#include <gtest/gtest.h>

#include <numeric>

using namespace std::chrono_literals;

namespace nano
{
// Test disabled because it's failing intermittently.
// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3512
// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3522
TEST (active_transactions, DISABLED_confirm_active)
{
	nano::system system;
	nano::node_flags node_flags;
	node_flags.disable_request_loop = true;
	auto & node1 = *system.add_node (node_flags);
	auto send = nano::send_block_builder ()
				.previous (nano::dev::genesis->hash ())
				.destination (nano::public_key ())
				.balance (nano::dev::constants.genesis_amount - 100)
				.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				.work (*system.work.generate (nano::dev::genesis->hash ()))
				.build_shared ();
	ASSERT_EQ (nano::process_result::progress, node1.process (*send).code);
	nano::node_config node_config2 (nano::get_available_port (), system.logging);
	node_config2.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
	nano::node_flags node_flags2;
	// The rep crawler would otherwise request confirmations in order to find representatives
	node_flags2.disable_rep_crawler = true;
	auto & node2 = *system.add_node (node_config2, node_flags2);
	system.deadline_set (5s);
	// Let node2 know about the block
	while (node2.active.empty ())
	{
		node1.network.flood_block (send, nano::buffer_drop_policy::no_limiter_drop);
		ASSERT_NO_ERROR (system.poll ());
	}
	// Save election to check request count afterwards
	auto election = node2.active.election (send->qualified_root ());
	ASSERT_NE (nullptr, election);
	// Add key to node1
	system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
	// Add representative to disabled rep crawler
	auto peers (node2.network.random_set (1));
	ASSERT_FALSE (peers.empty ());
	{
		nano::lock_guard<nano::mutex> guard (node2.rep_crawler.probable_reps_mutex);
		node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, *peers.begin ());
	}
	ASSERT_TIMELY (5s, election->votes ().size () != 1); // Votes were inserted (except for the null account)
	auto confirm_req_count (election->confirmation_request_count.load ());
	// At least one confirmation request
	ASSERT_GT (confirm_req_count, 0u);
	ASSERT_FALSE (election->confirmed ()); // Cannot be confirmed without final vote
	node1.confirmation_height_processor.add (send); // Confirm block for node1 for final vote generation
	ASSERT_TIMELY (5s, node1.ledger.block_confirmed (node1.store.tx_begin_read (), send->hash ()));
	node1.history.erase (send->root ()); // Have to erase existing non-final vote for final vote generation (at runtime it should be replaced with automatically generated final vote from election)
	// Waiting for final confirmation
	ASSERT_TIMELY (10s, node2.ledger.cache.cemented_count == 2 && node2.active.empty ());
	// At least one more confirmation request
	ASSERT_GT (election->confirmation_request_count, confirm_req_count);
	// Blocks were cleared (except for the null account)
	ASSERT_EQ (1, election->blocks ().size ());
}
}

namespace nano
{
TEST (active_transactions, confirm_frontier)
{
	nano::system system;
	nano::node_flags node_flags;
	node_flags.disable_request_loop = true;
	// Voting node
	auto & node1 = *system.add_node (node_flags);
	nano::node_flags node_flags2;
	// The rep crawler would otherwise request confirmations in order to find representatives
	node_flags2.disable_rep_crawler = true;
	auto & node2 = *system.add_node (node_flags2);

	// Add key to node1
	system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
	// Add representative to disabled rep crawler
	auto peers (node2.network.random_set (1));
	ASSERT_FALSE (peers.empty ());
	{
		nano::lock_guard<nano::mutex> guard (node2.rep_crawler.probable_reps_mutex);
		node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, *peers.begin ());
	}

	nano::state_block_builder builder;
	auto send = builder
				.account (nano::dev::genesis_key.pub)
				.previous (nano::dev::genesis->hash ())
				.representative (nano::dev::genesis_key.pub)
				.balance (nano::dev::constants.genesis_amount - 100)
				.link (nano::public_key ())
				.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				.work (*system.work.generate (nano::dev::genesis->hash ()))
				.build_shared ();
	auto send_copy = builder.make_block ().from (*send).build_shared ();
	ASSERT_EQ (nano::process_result::progress, node1.process (*send).code);
	node1.confirmation_height_processor.add (send);
	ASSERT_TIMELY (5s, node1.ledger.block_confirmed (node1.store.tx_begin_read (), send->hash ()));
	ASSERT_EQ (nano::process_result::progress, node2.process (*send_copy).code);
	ASSERT_TIMELY (5s, !node2.active.empty ());
	// Save election to check request count afterwards
	auto election2 = node2.active.election (send->qualified_root ());
	ASSERT_NE (nullptr, election2);
	ASSERT_TIMELY (5s, node2.ledger.cache.cemented_count == 2 && node2.active.empty ());
	ASSERT_GT (election2->confirmation_request_count, 0u);
}
}

TEST (active_transactions, keep_local)
{
	nano::system system;
	nano::node_config node_config (nano::get_available_port (), system.logging);
	node_config.enable_voting = false;
	node_config.active_elections_size = 2; //bound to 2, wont drop wallet created transactions, but good to test dropping remote
	// Disable frontier confirmation to allow the test to finish before
	node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
	auto & node = *system.add_node (node_config);
	auto & wallet (*system.wallet (0));
	//key 1/2 will be managed by the wallet
	nano::keypair key1, key2, key3, key4, key5, key6;
	wallet.insert_adhoc (nano::dev::genesis_key.prv);
	auto send1 (wallet.send_action (nano::dev::genesis_key.pub, key1.pub, node.config.receive_minimum.number ()));
	auto send2 (wallet.send_action (nano::dev::genesis_key.pub, key2.pub, node.config.receive_minimum.number ()));
	auto send3 (wallet.send_action (nano::dev::genesis_key.pub, key3.pub, node.config.receive_minimum.number ()));
	auto send4 (wallet.send_action (nano::dev::genesis_key.pub, key4.pub, node.config.receive_minimum.number ()));
	auto send5 (wallet.send_action (nano::dev::genesis_key.pub, key5.pub, node.config.receive_minimum.number ()));
	auto send6 (wallet.send_action (nano::dev::genesis_key.pub, key6.pub, node.config.receive_minimum.number ()));
	// should not drop wallet created transactions
	ASSERT_TIMELY (5s, node.active.size () == 1);
	for (auto const & block : { send1, send2, send3, send4, send5, send6 })
	{
		ASSERT_TIMELY (1s, node.active.election (block->qualified_root ()));
		auto election = node.active.election (block->qualified_root ());
		ASSERT_NE (nullptr, election);
		election->force_confirm ();
	}
	ASSERT_TIMELY (5s, node.active.empty ());
	nano::state_block_builder builder;
	auto open1 = builder.make_block ()
				 .account (key1.pub)
				 .previous (0)
				 .representative (key1.pub)
				 .balance (node.config.receive_minimum.number ())
				 .link (send1->hash ())
				 .sign (key1.prv, key1.pub)
				 .work (*system.work.generate (key1.pub))
				 .build_shared ();
	auto open2 = builder.make_block ()
				 .account (key2.pub)
				 .previous (0)
				 .representative (key2.pub)
				 .balance (node.config.receive_minimum.number ())
				 .link (send2->hash ())
				 .sign (key2.prv, key2.pub)
				 .work (*system.work.generate (key2.pub))
				 .build_shared ();
	auto open3 = builder.make_block ()
				 .account (key3.pub)
				 .previous (0)
				 .representative (key3.pub)
				 .balance (node.config.receive_minimum.number ())
				 .link (send3->hash ())
				 .sign (key3.prv, key3.pub)
				 .work (*system.work.generate (key3.pub))
				 .build_shared ();
	node.process_active (open1);
	node.process_active (open2);
	node.process_active (open3);
	node.block_processor.flush ();
	// bound elections, should drop after one loop
	ASSERT_TIMELY (1s, node.active.size () == node_config.active_elections_size);
	ASSERT_EQ (1, node.scheduler.size ());
}

TEST (active_transactions, inactive_votes_cache)
{
	nano::system system (1);
	auto & node = *system.nodes[0];
	nano::block_hash latest (node.latest (nano::dev::genesis_key.pub));
	nano::keypair key;
	auto send = nano::send_block_builder ()
				.previous (latest)
				.destination (key.pub)
				.balance (nano::dev::constants.genesis_amount - 100)
				.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				.work (*system.work.generate (latest))
				.build_shared ();
	auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, std::vector<nano::block_hash> (1, send->hash ())));
	node.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node));
	ASSERT_TIMELY (5s, node.active.inactive_votes_cache_size () == 1);
	node.process_active (send);
	node.block_processor.flush ();
	ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send->hash ()));
	ASSERT_EQ (1, node.stats.count (nano::stat::type::election, nano::stat::detail::vote_cached));
}

TEST (active_transactions, inactive_votes_cache_non_final)
{
	nano::system system (1);
	auto & node = *system.nodes[0];
	nano::block_hash latest (node.latest (nano::dev::genesis_key.pub));
	nano::keypair key;
	auto send = nano::send_block_builder ()
				.previous (latest)
				.destination (key.pub)
				.balance (nano::dev::constants.genesis_amount - 100)
				.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				.work (*system.work.generate (latest))
				.build_shared ();
	auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, std::vector<nano::block_hash> (1, send->hash ()))); // Non-final vote
	node.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node));
	ASSERT_TIMELY (5s, node.active.inactive_votes_cache_size () == 1);
	node.process_active (send);
	node.block_processor.flush ();
	ASSERT_TIMELY (5s, node.stats.count (nano::stat::type::election, nano::stat::detail::vote_cached) == 1);
	auto election = node.active.election (send->qualified_root ());
	ASSERT_NE (nullptr, election);
	ASSERT_FALSE (election->confirmed ());
	ASSERT_EQ (nano::dev::constants.genesis_amount - 100, election->tally ().begin ()->first);
}

TEST (active_transactions, inactive_votes_cache_fork)
{
	nano::system system (1);
	auto & node = *system.nodes[0];
	nano::block_hash latest (node.latest (nano::dev::genesis_key.pub));
	nano::keypair key;
	nano::send_block_builder builder;
	auto send1 = builder.make_block ()
				 .previous (latest)
				 .destination (key.pub)
				 .balance (nano::dev::constants.genesis_amount - 100)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (latest))
				 .build_shared ();
	auto send2 = builder.make_block ()
				 .previous (latest)
				 .destination (key.pub)
				 .balance (nano::dev::constants.genesis_amount - 200)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (latest))
				 .build_shared ();
	auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, std::vector<nano::block_hash> (1, send1->hash ())));
	node.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node));
	auto channel1 (node.network.udp_channels.create (node.network.endpoint ()));
	ASSERT_TIMELY (5s, node.active.inactive_votes_cache_size () == 1);
	node.network.inbound (nano::publish{ nano::dev::network_params.network, send2 }, channel1);
	node.block_processor.flush ();
	ASSERT_NE (nullptr, node.block (send2->hash ()));
	node.scheduler.flush (); // Start election, otherwise conflicting block won't be inserted into election
	node.network.inbound (nano::publish{ nano::dev::network_params.network, send1 }, channel1);
	node.block_processor.flush ();
	bool confirmed (false);
	system.deadline_set (5s);
	while (!confirmed)
	{
		auto transaction (node.store.tx_begin_read ());
		confirmed = node.block (send1->hash ()) != nullptr && node.ledger.block_confirmed (transaction, send1->hash ()) && node.active.empty ();
		ASSERT_NO_ERROR (system.poll ());
	}
	ASSERT_EQ (1, node.stats.count (nano::stat::type::election, nano::stat::detail::vote_cached));
}

TEST (active_transactions, inactive_votes_cache_existing_vote)
{
	nano::system system;
	nano::node_config node_config (nano::get_available_port (), system.logging);
	node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
	auto & node = *system.add_node (node_config);
	nano::block_hash latest (node.latest (nano::dev::genesis_key.pub));
	nano::keypair key;
	nano::block_builder builder;
	auto send = builder.send ()
				.previous (latest)
				.destination (key.pub)
				.balance (nano::dev::constants.genesis_amount - 100 * nano::Gxrb_ratio)
				.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				.work (*system.work.generate (latest))
				.build_shared ();
	auto open = builder.state ()
				.account (key.pub)
				.previous (0)
				.representative (key.pub)
				.balance (100 * nano::Gxrb_ratio)
				.link (send->hash ())
				.sign (key.prv, key.pub)
				.work (*system.work.generate (key.pub))
				.build_shared ();
	node.process_active (send);
	node.block_processor.add (open);
	node.block_processor.flush ();
	ASSERT_TIMELY (5s, node.active.size () == 1);
	auto election (node.active.election (send->qualified_root ()));
	ASSERT_NE (nullptr, election);
	ASSERT_GT (node.weight (key.pub), node.minimum_principal_weight ());
	// Insert vote
	auto vote1 (std::make_shared<nano::vote> (key.pub, key.prv, nano::vote::timestamp_min * 1, std::vector<nano::block_hash> (1, send->hash ())));
	node.vote_processor.vote (vote1, std::make_shared<nano::transport::channel_loopback> (node));
	ASSERT_TIMELY (5s, election->votes ().size () == 2);
	ASSERT_EQ (1, node.stats.count (nano::stat::type::election, nano::stat::detail::vote_new));
	auto last_vote1 (election->votes ()[key.pub]);
	ASSERT_EQ (send->hash (), last_vote1.hash);
	ASSERT_EQ (nano::vote::timestamp_min * 1, last_vote1.timestamp);
	// Attempt to change vote with inactive_votes_cache
	nano::unique_lock<nano::mutex> active_lock (node.active.mutex);
	node.active.add_inactive_votes_cache (active_lock, send->hash (), key.pub, 0);
	active_lock.unlock ();
	auto cache (node.active.find_inactive_votes_cache (send->hash ()));
	active_lock.lock ();
	ASSERT_EQ (1, cache.voters.size ());
	election->insert_inactive_votes_cache (cache);
	// Check that election data is not changed
	ASSERT_EQ (2, election->votes ().size ());
	auto last_vote2 (election->votes ()[key.pub]);
	ASSERT_EQ (last_vote1.hash, last_vote2.hash);
	ASSERT_EQ (last_vote1.timestamp, last_vote2.timestamp);
	ASSERT_EQ (last_vote1.time, last_vote2.time);
	ASSERT_EQ (0, node.stats.count (nano::stat::type::election, nano::stat::detail::vote_cached));
}

TEST (active_transactions, inactive_votes_cache_multiple_votes)
{
	nano::system system;
	nano::node_config node_config (nano::get_available_port (), system.logging);
	node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
	auto & node = *system.add_node (node_config);
	nano::block_hash latest (node.latest (nano::dev::genesis_key.pub));
	nano::keypair key1;
	nano::block_builder builder;
	auto send1 = builder.send ()
				 .previous (latest)
				 .destination (key1.pub)
				 .balance (nano::dev::constants.genesis_amount - 100 * nano::Gxrb_ratio)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (latest))
				 .build_shared ();
	auto send2 = builder.send ()
				 .previous (send1->hash ())
				 .destination (key1.pub)
				 .balance (100 * nano::Gxrb_ratio)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (send1->hash ()))
				 .build_shared ();
	auto open = builder.state ()
				.account (key1.pub)
				.previous (0)
				.representative (key1.pub)
				.balance (100 * nano::Gxrb_ratio)
				.link (send1->hash ())
				.sign (key1.prv, key1.pub)
				.work (*system.work.generate (key1.pub))
				.build_shared ();
	node.block_processor.add (send1);
	node.block_processor.add (send2);
	node.block_processor.add (open);
	node.block_processor.flush ();
	// Process votes
	auto vote1 (std::make_shared<nano::vote> (key1.pub, key1.prv, 0, std::vector<nano::block_hash> (1, send1->hash ())));
	node.vote_processor.vote (vote1, std::make_shared<nano::transport::channel_loopback> (node));
	auto vote2 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, std::vector<nano::block_hash> (1, send1->hash ())));
	node.vote_processor.vote (vote2, std::make_shared<nano::transport::channel_loopback> (node));
	ASSERT_TIMELY (5s, node.active.find_inactive_votes_cache (send1->hash ()).voters.size () == 2);
	ASSERT_EQ (1, node.active.inactive_votes_cache_size ());
	node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
	node.scheduler.flush ();
	auto election = node.active.election (send1->qualified_root ());
	ASSERT_NE (nullptr, election);
	ASSERT_EQ (3, election->votes ().size ()); // 2 votes and 1 default not_an_acount
	ASSERT_EQ (2, node.stats.count (nano::stat::type::election, nano::stat::detail::vote_cached));
}

TEST (active_transactions, inactive_votes_cache_election_start)
{
	nano::system system;
	nano::node_config node_config (nano::get_available_port (), system.logging);
	node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
	auto & node = *system.add_node (node_config);
	nano::block_hash latest (node.latest (nano::dev::genesis_key.pub));
	nano::keypair key1, key2;
	nano::send_block_builder send_block_builder;
	nano::state_block_builder state_block_builder;
	auto send1 = send_block_builder.make_block ()
				 .previous (latest)
				 .destination (key1.pub)
				 .balance (nano::dev::constants.genesis_amount - 5000 * nano::Gxrb_ratio)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (latest))
				 .build_shared ();
	auto send2 = send_block_builder.make_block ()
				 .previous (send1->hash ())
				 .destination (key2.pub)
				 .balance (nano::dev::constants.genesis_amount - 10000 * nano::Gxrb_ratio)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (send1->hash ()))
				 .build_shared ();
	auto open1 = state_block_builder.make_block ()
				 .account (key1.pub)
				 .previous (0)
				 .representative (key1.pub)
				 .balance (5000 * nano::Gxrb_ratio)
				 .link (send1->hash ())
				 .sign (key1.prv, key1.pub)
				 .work (*system.work.generate (key1.pub))
				 .build_shared ();
	auto open2 = state_block_builder.make_block ()
				 .account (key2.pub)
				 .previous (0)
				 .representative (key2.pub)
				 .balance (5000 * nano::Gxrb_ratio)
				 .link (send2->hash ())
				 .sign (key2.prv, key2.pub)
				 .work (*system.work.generate (key2.pub))
				 .build_shared ();
	node.block_processor.add (send1);
	node.block_processor.add (send2);
	node.block_processor.add (open1);
	node.block_processor.add (open2);
	node.block_processor.flush ();
	ASSERT_TIMELY (5s, 5 == node.ledger.cache.block_count);
	ASSERT_TRUE (node.active.empty ());
	ASSERT_EQ (1, node.ledger.cache.cemented_count);
	// These blocks will be processed later
	auto send3 = send_block_builder.make_block ()
				 .previous (send2->hash ())
				 .destination (nano::keypair ().pub)
				 .balance (send2->balance ().number () - 1)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (send2->hash ()))
				 .build_shared ();
	auto send4 = send_block_builder.make_block ()
				 .previous (send3->hash ())
				 .destination (nano::keypair ().pub)
				 .balance (send3->balance ().number () - 1)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (send3->hash ()))
				 .build_shared ();
	// Inactive votes
	std::vector<nano::block_hash> hashes{ open1->hash (), open2->hash (), send4->hash () };
	auto vote1 (std::make_shared<nano::vote> (key1.pub, key1.prv, 0, hashes));
	node.vote_processor.vote (vote1, std::make_shared<nano::transport::channel_loopback> (node));
	ASSERT_TIMELY (5s, node.active.inactive_votes_cache_size () == 3);
	ASSERT_TRUE (node.active.empty ());
	ASSERT_EQ (1, node.ledger.cache.cemented_count);
	// 2 votes are required to start election (dev network)
	auto vote2 (std::make_shared<nano::vote> (key2.pub, key2.prv, 0, hashes));
	node.vote_processor.vote (vote2, std::make_shared<nano::transport::channel_loopback> (node));
	// Only open1 & open2 blocks elections should start (send4 is missing previous block in ledger)
	ASSERT_TIMELY (5s, 2 == node.active.size ());
	// Confirm elections with weight quorum
	auto vote0 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, hashes)); // Final vote for confirmation
	node.vote_processor.vote (vote0, std::make_shared<nano::transport::channel_loopback> (node));
	ASSERT_TIMELY (5s, node.active.empty ());
	ASSERT_TIMELY (5s, 5 == node.ledger.cache.cemented_count);
	// A late block arrival also checks the inactive votes cache
	ASSERT_TRUE (node.active.empty ());
	auto send4_cache (node.active.find_inactive_votes_cache (send4->hash ()));
	ASSERT_EQ (3, send4_cache.voters.size ());
	ASSERT_TRUE (send4_cache.status.bootstrap_started);
	ASSERT_TRUE (send4_cache.status.confirmed);
	ASSERT_TRUE (send4_cache.status.election_started); // already marked even though the block does not exist
	node.process_active (send3);
	node.block_processor.flush ();
	// An election is started for send6 but does not confirm
	ASSERT_TIMELY (5s, 1 == node.active.size ());
	node.vote_processor.flush ();
	ASSERT_FALSE (node.block_confirmed_or_being_confirmed (node.store.tx_begin_read (), send3->hash ()));
	// send7 cannot be voted on but an election should be started from inactive votes
	ASSERT_FALSE (node.ledger.dependents_confirmed (node.store.tx_begin_read (), *send4));
	node.process_active (send4);
	node.block_processor.flush ();
	ASSERT_TIMELY (5s, 7 == node.ledger.cache.cemented_count);
}

namespace nano
{
TEST (active_transactions, vote_replays)
{
	nano::system system;
	nano::node_config node_config (nano::get_available_port (), system.logging);
	node_config.enable_voting = false;
	node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
	auto & node = *system.add_node (node_config);
	nano::keypair key;
	nano::state_block_builder builder;
	auto send1 = builder.make_block ()
				 .account (nano::dev::genesis_key.pub)
				 .previous (nano::dev::genesis->hash ())
				 .representative (nano::dev::genesis_key.pub)
				 .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
				 .link (key.pub)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (nano::dev::genesis->hash ()))
				 .build_shared ();
	ASSERT_NE (nullptr, send1);
	auto open1 = builder.make_block ()
				 .account (key.pub)
				 .previous (0)
				 .representative (key.pub)
				 .balance (nano::Gxrb_ratio)
				 .link (send1->hash ())
				 .sign (key.prv, key.pub)
				 .work (*system.work.generate (key.pub))
				 .build_shared ();
	ASSERT_NE (nullptr, open1);
	node.process_active (send1);
	node.process_active (open1);
	nano::blocks_confirm (node, { send1, open1 });
	ASSERT_EQ (2, node.active.size ());
	// First vote is not a replay and confirms the election, second vote should be a replay since the election has confirmed but not yet removed
	auto vote_send1 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, send1));
	ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_send1));
	ASSERT_EQ (2, node.active.size ());
	ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_send1));
	// Wait until the election is removed, at which point the vote is still a replay since it's been recently confirmed
	ASSERT_TIMELY (3s, node.active.size () == 1);
	ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_send1));
	// Open new account
	auto vote_open1 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, open1));
	ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_open1));
	ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_open1));
	ASSERT_TIMELY (3s, node.active.empty ());
	ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_open1));
	ASSERT_EQ (nano::Gxrb_ratio, node.ledger.weight (key.pub));

	auto send2 = builder.make_block ()
				 .account (key.pub)
				 .previous (open1->hash ())
				 .representative (key.pub)
				 .balance (nano::Gxrb_ratio - 1)
				 .link (key.pub)
				 .sign (key.prv, key.pub)
				 .work (*system.work.generate (open1->hash ()))
				 .build_shared ();
	ASSERT_NE (nullptr, send2);
	node.process_active (send2);
	nano::blocks_confirm (node, { send2 });
	ASSERT_EQ (1, node.active.size ());
	auto vote1_send2 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, send2));
	auto vote2_send2 (std::make_shared<nano::vote> (key.pub, key.prv, 0, send2));
	ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote2_send2));
	ASSERT_EQ (1, node.active.size ());
	ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote2_send2));
	ASSERT_EQ (1, node.active.size ());
	ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote1_send2));
	ASSERT_EQ (1, node.active.size ());
	ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote1_send2));
	ASSERT_TIMELY (3s, node.active.empty ());
	ASSERT_EQ (0, node.active.size ());
	ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote1_send2));
	ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote2_send2));

	// Removing blocks as recently confirmed makes every vote indeterminate
	{
		nano::lock_guard<nano::mutex> guard (node.active.mutex);
		node.active.recently_confirmed.clear ();
	}
	ASSERT_EQ (nano::vote_code::indeterminate, node.active.vote (vote_send1));
	ASSERT_EQ (nano::vote_code::indeterminate, node.active.vote (vote_open1));
	ASSERT_EQ (nano::vote_code::indeterminate, node.active.vote (vote1_send2));
	ASSERT_EQ (nano::vote_code::indeterminate, node.active.vote (vote2_send2));
}
}

// Tests that blocks are correctly cleared from the duplicate filter for unconfirmed elections
TEST (active_transactions, dropped_cleanup)
{
	nano::system system;
	nano::node_flags flags;
	flags.disable_request_loop = true;
	auto & node (*system.add_node (flags));

	// Add to network filter to ensure proper cleanup after the election is dropped
	std::vector<uint8_t> block_bytes;
	{
		nano::vectorstream stream (block_bytes);
		nano::dev::genesis->serialize (stream);
	}
	ASSERT_FALSE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ()));
	ASSERT_TRUE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ()));

	node.block_confirm (nano::dev::genesis);
	node.scheduler.flush ();
	auto election = node.active.election (nano::dev::genesis->qualified_root ());
	ASSERT_NE (nullptr, election);

	// Not yet removed
	ASSERT_TRUE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ()));
	ASSERT_EQ (1, node.active.blocks.count (nano::dev::genesis->hash ()));

	// Now simulate dropping the election
	ASSERT_FALSE (election->confirmed ());
	node.active.erase (*nano::dev::genesis);

	// The filter must have been cleared
	ASSERT_FALSE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ()));

	// An election was recently dropped
	ASSERT_EQ (1, node.stats.count (nano::stat::type::election, nano::stat::detail::election_drop_all));

	// Block cleared from active
	ASSERT_EQ (0, node.active.blocks.count (nano::dev::genesis->hash ()));

	// Repeat test for a confirmed election
	ASSERT_TRUE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ()));
	node.block_confirm (nano::dev::genesis);
	node.scheduler.flush ();
	election = node.active.election (nano::dev::genesis->qualified_root ());
	ASSERT_NE (nullptr, election);
	election->force_confirm ();
	ASSERT_TRUE (election->confirmed ());
	node.active.erase (*nano::dev::genesis);

	// The filter should not have been cleared
	ASSERT_TRUE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ()));

	// Not dropped
	ASSERT_EQ (1, node.stats.count (nano::stat::type::election, nano::stat::detail::election_drop_all));

	// Block cleared from active
	ASSERT_EQ (0, node.active.blocks.count (nano::dev::genesis->hash ()));
}

TEST (active_transactions, republish_winner)
{
	nano::system system;
	nano::node_config node_config{ nano::get_available_port (), system.logging };
	node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
	auto & node1 = *system.add_node (node_config);
	node_config.peering_port = nano::get_available_port ();
	auto & node2 = *system.add_node (node_config);

	nano::keypair key;
	nano::state_block_builder builder;
	auto send1 = builder.make_block ()
				 .account (nano::dev::genesis_key.pub)
				 .previous (nano::dev::genesis->hash ())
				 .representative (nano::dev::genesis_key.pub)
				 .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
				 .link (key.pub)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (nano::dev::genesis->hash ()))
				 .build_shared ();

	node1.process_active (send1);
	node1.block_processor.flush ();
	ASSERT_TIMELY (3s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) == 1);

	// Several forks
	for (auto i (0); i < 5; i++)
	{
		auto fork = builder.make_block ()
					.account (nano::dev::genesis_key.pub)
					.previous (nano::dev::genesis->hash ())
					.representative (nano::dev::genesis_key.pub)
					.balance (nano::dev::constants.genesis_amount - 1 - i)
					.link (key.pub)
					.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
					.work (*system.work.generate (nano::dev::genesis->hash ()))
					.build_shared ();
		node1.process_active (fork);
	}
	node1.block_processor.flush ();
	ASSERT_TIMELY (3s, !node1.active.empty ());
	ASSERT_EQ (1, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in));

	// Process new fork with vote to change winner
	auto fork = builder.make_block ()
				.account (nano::dev::genesis_key.pub)
				.previous (nano::dev::genesis->hash ())
				.representative (nano::dev::genesis_key.pub)
				.balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio)
				.link (key.pub)
				.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				.work (*system.work.generate (nano::dev::genesis->hash ()))
				.build_shared ();

	node1.process_active (fork);
	node1.block_processor.flush ();
	auto election = node1.active.election (fork->qualified_root ());
	ASSERT_NE (nullptr, election);
	auto vote = std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, std::vector<nano::block_hash>{ fork->hash () });
	node1.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node1));
	node1.vote_processor.flush ();
	node1.block_processor.flush ();
	ASSERT_TIMELY (3s, election->confirmed ());
	ASSERT_EQ (fork->hash (), election->status.winner->hash ());
	ASSERT_TIMELY (3s, node2.block_confirmed (fork->hash ()));
}

TEST (active_transactions, fork_filter_cleanup)
{
	nano::system system;
	nano::node_config node_config (nano::get_available_port (), system.logging);
	node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
	auto & node1 (*system.add_node (node_config));

	nano::keypair key;
	nano::state_block_builder builder;
	auto send1 = builder.make_block ()
				 .account (nano::dev::genesis_key.pub)
				 .previous (nano::dev::genesis->hash ())
				 .representative (nano::dev::genesis_key.pub)
				 .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
				 .link (key.pub)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (nano::dev::genesis->hash ()))
				 .build_shared ();
	std::vector<uint8_t> block_bytes;
	{
		nano::vectorstream stream (block_bytes);
		send1->serialize (stream);
	}

	// Generate 10 forks to prevent new block insertion to election
	for (auto i (0); i < 10; i++)
	{
		auto fork = builder.make_block ()
					.account (nano::dev::genesis_key.pub)
					.previous (nano::dev::genesis->hash ())
					.representative (nano::dev::genesis_key.pub)
					.balance (nano::dev::constants.genesis_amount - 1 - i)
					.link (key.pub)
					.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
					.work (*system.work.generate (nano::dev::genesis->hash ()))
					.build_shared ();
		node1.process_active (fork);
		node1.block_processor.flush ();
		node1.scheduler.flush ();
	}
	ASSERT_EQ (1, node1.active.size ());

	// Process correct block
	node_config.peering_port = nano::get_available_port ();
	auto & node2 (*system.add_node (node_config));
	node2.network.flood_block (send1);
	ASSERT_TIMELY (3s, node1.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) > 0);
	node1.block_processor.flush ();
	std::this_thread::sleep_for (50ms);

	// Block is erased from the duplicate filter
	ASSERT_FALSE (node1.network.publish_filter.apply (block_bytes.data (), block_bytes.size ()));

	auto election (node1.active.election (send1->qualified_root ()));
	ASSERT_NE (nullptr, election);
	ASSERT_EQ (10, election->blocks ().size ());
}

TEST (active_transactions, fork_replacement_tally)
{
	nano::system system;
	nano::node_config node_config (nano::get_available_port (), system.logging);
	node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
	auto & node1 (*system.add_node (node_config));

	size_t reps_count = 20;
	size_t const max_blocks = 10;
	std::vector<nano::keypair> keys (reps_count);
	auto latest (nano::dev::genesis->hash ());
	auto balance (nano::dev::constants.genesis_amount);
	auto amount (node1.minimum_principal_weight ());
	nano::state_block_builder builder;

	// Create 20 representatives & confirm blocks
	for (auto i (0); i < reps_count; i++)
	{
		balance -= amount + i;
		auto send = builder.make_block ()
					.account (nano::dev::genesis_key.pub)
					.previous (latest)
					.representative (nano::dev::genesis_key.pub)
					.balance (balance)
					.link (keys[i].pub)
					.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
					.work (*system.work.generate (latest))
					.build_shared ();
		node1.process_active (send);
		latest = send->hash ();
		auto open = builder.make_block ()
					.account (keys[i].pub)
					.previous (0)
					.representative (keys[i].pub)
					.balance (amount + i)
					.link (send->hash ())
					.sign (keys[i].prv, keys[i].pub)
					.work (*system.work.generate (keys[i].pub))
					.build_shared ();
		node1.process_active (open);
		// Confirmation
		auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, std::vector<nano::block_hash>{ send->hash (), open->hash () }));
		node1.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node1));
	}
	node1.block_processor.flush ();
	ASSERT_TIMELY (5s, node1.ledger.cache.cemented_count == 1 + 2 * reps_count);

	nano::keypair key;
	auto send_last = builder.make_block ()
					 .account (nano::dev::genesis_key.pub)
					 .previous (latest)
					 .representative (nano::dev::genesis_key.pub)
					 .balance (balance - 2 * nano::Gxrb_ratio)
					 .link (key.pub)
					 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
					 .work (*system.work.generate (latest))
					 .build_shared ();

	// Forks without votes
	for (auto i (0); i < reps_count; i++)
	{
		auto fork = builder.make_block ()
					.account (nano::dev::genesis_key.pub)
					.previous (latest)
					.representative (nano::dev::genesis_key.pub)
					.balance (balance - nano::Gxrb_ratio - i)
					.link (key.pub)
					.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
					.work (*system.work.generate (latest))
					.build_shared ();
		node1.process_active (fork);
	}
	node1.block_processor.flush ();
	ASSERT_TIMELY (3s, !node1.active.empty ());
	// Check overflow of blocks
	auto election (node1.active.election (send_last->qualified_root ()));
	ASSERT_NE (nullptr, election);
	ASSERT_EQ (max_blocks, election->blocks ().size ());

	// Generate forks with votes to prevent new block insertion to election
	for (auto i (0); i < reps_count; i++)
	{
		auto fork = builder.make_block ()
					.account (nano::dev::genesis_key.pub)
					.previous (latest)
					.representative (nano::dev::genesis_key.pub)
					.balance (balance - 1 - i)
					.link (key.pub)
					.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
					.work (*system.work.generate (latest))
					.build_shared ();
		auto vote (std::make_shared<nano::vote> (keys[i].pub, keys[i].prv, 0, std::vector<nano::block_hash>{ fork->hash () }));
		node1.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node1));
		node1.vote_processor.flush ();
		node1.process_active (fork);
	}
	node1.block_processor.flush ();
	// Check overflow of blocks
	ASSERT_EQ (max_blocks, election->blocks ().size ());
	// Check that only max weight blocks remains (and start winner)
	auto votes1 (election->votes ());
	ASSERT_EQ (max_blocks, votes1.size ());
	for (auto i (max_blocks + 1); i < reps_count; i++)
	{
		ASSERT_TRUE (votes1.find (keys[i].pub) != votes1.end ());
	}

	// Process correct block
	node_config.peering_port = nano::get_available_port ();
	auto & node2 (*system.add_node (node_config));
	node2.network.flood_block (send_last);
	ASSERT_TIMELY (3s, node1.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) > 0);
	node1.block_processor.flush ();
	std::this_thread::sleep_for (50ms);

	// Correct block without votes is ignored
	auto blocks1 (election->blocks ());
	ASSERT_EQ (max_blocks, blocks1.size ());
	ASSERT_FALSE (blocks1.find (send_last->hash ()) != blocks1.end ());

	// Process vote for correct block & replace existing lowest tally block
	auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, std::vector<nano::block_hash>{ send_last->hash () }));
	node1.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node1));
	node1.vote_processor.flush ();
	node2.network.flood_block (send_last);
	ASSERT_TIMELY (3s, node1.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) > 1);
	node1.block_processor.flush ();
	std::this_thread::sleep_for (50ms);

	auto blocks2 (election->blocks ());
	ASSERT_EQ (max_blocks, blocks2.size ());
	ASSERT_TRUE (blocks2.find (send_last->hash ()) != blocks2.end ());
	auto votes2 (election->votes ());
	ASSERT_EQ (max_blocks, votes2.size ());
	for (auto i (max_blocks + 2); i < reps_count; i++)
	{
		ASSERT_TRUE (votes2.find (keys[i].pub) != votes2.end ());
	}
	ASSERT_FALSE (votes2.find (keys[max_blocks].pub) != votes2.end ());
	ASSERT_FALSE (votes2.find (keys[max_blocks + 1].pub) != votes2.end ());
	ASSERT_TRUE (votes2.find (nano::dev::genesis_key.pub) != votes2.end ());
}

namespace nano
{
// Blocks that won an election must always be seen as confirming or cemented
TEST (active_transactions, confirmation_consistency)
{
	nano::system system;
	nano::node_config node_config (nano::get_available_port (), system.logging);
	node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
	auto & node = *system.add_node (node_config);
	system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
	for (unsigned i = 0; i < 10; ++i)
	{
		auto block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::public_key (), node.config.receive_minimum.number ()));
		ASSERT_NE (nullptr, block);
		system.deadline_set (5s);
		while (!node.ledger.block_confirmed (node.store.tx_begin_read (), block->hash ()))
		{
			node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
			ASSERT_NO_ERROR (system.poll (5ms));
		}
		ASSERT_NO_ERROR (system.poll_until_true (1s, [&node, &block, i] {
			nano::lock_guard<nano::mutex> guard (node.active.mutex);
			EXPECT_EQ (i + 1, node.active.recently_confirmed.size ());
			EXPECT_EQ (block->qualified_root (), node.active.recently_confirmed.back ().first);
			return i + 1 == node.active.recently_cemented.size (); // done after a callback
		}));
	}
}
}

TEST (active_transactions, confirm_new)
{
	nano::system system (1);
	auto & node1 = *system.nodes[0];
	auto send = nano::send_block_builder ()
				.previous (nano::dev::genesis->hash ())
				.destination (nano::public_key ())
				.balance (nano::dev::constants.genesis_amount - 100)
				.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				.work (*system.work.generate (nano::dev::genesis->hash ()))
				.build_shared ();
	node1.process_active (send);
	node1.block_processor.flush ();
	node1.scheduler.flush ();
	ASSERT_EQ (1, node1.active.size ());
	auto & node2 = *system.add_node ();
	// Add key to node2
	system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv);
	// Let node2 know about the block
	ASSERT_TIMELY (5s, node2.block (send->hash ()));
	// Wait confirmation
	ASSERT_TIMELY (5s, node1.ledger.cache.cemented_count == 2 && node2.ledger.cache.cemented_count == 2);
}

// Ensures votes are tallied on election::publish even if no vote is inserted through inactive_votes_cache
TEST (active_transactions, conflicting_block_vote_existing_election)
{
	nano::system system;
	nano::node_flags node_flags;
	node_flags.disable_request_loop = true;
	auto & node = *system.add_node (node_flags);
	nano::keypair key;
	nano::state_block_builder builder;
	auto send = builder.make_block ()
				.account (nano::dev::genesis_key.pub)
				.previous (nano::dev::genesis->hash ())
				.representative (nano::dev::genesis_key.pub)
				.balance (nano::dev::constants.genesis_amount - 100)
				.link (key.pub)
				.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				.work (*system.work.generate (nano::dev::genesis->hash ()))
				.build_shared ();
	auto fork = builder.make_block ()
				.account (nano::dev::genesis_key.pub)
				.previous (nano::dev::genesis->hash ())
				.representative (nano::dev::genesis_key.pub)
				.balance (nano::dev::constants.genesis_amount - 200)
				.link (key.pub)
				.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				.work (*system.work.generate (nano::dev::genesis->hash ()))
				.build_shared ();
	auto vote_fork (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, fork));

	ASSERT_EQ (nano::process_result::progress, node.process_local (send).code);
	node.scheduler.flush ();
	ASSERT_EQ (1, node.active.size ());

	// Vote for conflicting block, but the block does not yet exist in the ledger
	node.active.vote (vote_fork);

	// Block now gets processed
	ASSERT_EQ (nano::process_result::fork, node.process_local (fork).code);

	// Election must be confirmed
	auto election (node.active.election (fork->qualified_root ()));
	ASSERT_NE (nullptr, election);
	ASSERT_TIMELY (3s, election->confirmed ());
}

TEST (active_transactions, activate_account_chain)
{
	nano::system system;
	nano::node_flags flags;
	nano::node_config config (nano::get_available_port (), system.logging);
	config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
	auto & node = *system.add_node (config, flags);

	nano::keypair key;
	nano::state_block_builder builder;
	auto send = builder.make_block ()
				.account (nano::dev::genesis_key.pub)
				.previous (nano::dev::genesis->hash ())
				.representative (nano::dev::genesis_key.pub)
				.link (nano::dev::genesis_key.pub)
				.balance (nano::dev::constants.genesis_amount - 1)
				.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				.work (*system.work.generate (nano::dev::genesis->hash ()))
				.build ();
	auto send2 = builder.make_block ()
				 .account (nano::dev::genesis_key.pub)
				 .previous (send->hash ())
				 .representative (nano::dev::genesis_key.pub)
				 .link (key.pub)
				 .balance (nano::dev::constants.genesis_amount - 2)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (send->hash ()))
				 .build ();
	auto send3 = builder.make_block ()
				 .account (nano::dev::genesis_key.pub)
				 .previous (send2->hash ())
				 .representative (nano::dev::genesis_key.pub)
				 .link (key.pub)
				 .balance (nano::dev::constants.genesis_amount - 3)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (send2->hash ()))
				 .build ();
	auto open = builder.make_block ()
				.account (key.pub)
				.previous (0)
				.representative (key.pub)
				.link (send2->hash ())
				.balance (1)
				.sign (key.prv, key.pub)
				.work (*system.work.generate (key.pub))
				.build ();
	auto receive = builder.make_block ()
				   .account (key.pub)
				   .previous (open->hash ())
				   .representative (key.pub)
				   .link (send3->hash ())
				   .balance (2)
				   .sign (key.prv, key.pub)
				   .work (*system.work.generate (open->hash ()))
				   .build ();
	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
	ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
	ASSERT_EQ (nano::process_result::progress, node.process (*send3).code);
	ASSERT_EQ (nano::process_result::progress, node.process (*open).code);
	ASSERT_EQ (nano::process_result::progress, node.process (*receive).code);

	node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
	node.scheduler.flush ();
	auto election1 = node.active.election (send->qualified_root ());
	ASSERT_EQ (1, node.active.size ());
	ASSERT_EQ (1, election1->blocks ().count (send->hash ()));
	node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
	auto election2 = node.active.election (send->qualified_root ());
	ASSERT_EQ (election2, election1);
	election1->force_confirm ();
	ASSERT_TIMELY (3s, node.block_confirmed (send->hash ()));
	// On cementing, the next election is started
	ASSERT_TIMELY (3s, node.active.active (send2->qualified_root ()));
	node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
	auto election3 = node.active.election (send2->qualified_root ());
	ASSERT_NE (nullptr, election3);
	ASSERT_EQ (1, election3->blocks ().count (send2->hash ()));
	election3->force_confirm ();
	ASSERT_TIMELY (3s, node.block_confirmed (send2->hash ()));
	// On cementing, the next election is started
	ASSERT_TIMELY (3s, node.active.active (open->qualified_root ()));
	ASSERT_TIMELY (3s, node.active.active (send3->qualified_root ()));
	node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
	auto election4 = node.active.election (send3->qualified_root ());
	ASSERT_NE (nullptr, election4);
	ASSERT_EQ (1, election4->blocks ().count (send3->hash ()));
	node.scheduler.activate (key.pub, node.store.tx_begin_read ());
	auto election5 = node.active.election (open->qualified_root ());
	ASSERT_NE (nullptr, election5);
	ASSERT_EQ (1, election5->blocks ().count (open->hash ()));
	election5->force_confirm ();
	ASSERT_TIMELY (3s, node.block_confirmed (open->hash ()));
	// Until send3 is also confirmed, the receive block should not activate
	std::this_thread::sleep_for (200ms);
	node.scheduler.activate (key.pub, node.store.tx_begin_read ());
	election4->force_confirm ();
	ASSERT_TIMELY (3s, node.block_confirmed (send3->hash ()));
	ASSERT_TIMELY (3s, node.active.active (receive->qualified_root ()));
}

TEST (active_transactions, activate_inactive)
{
	nano::system system;
	nano::node_flags flags;
	nano::node_config config (nano::get_available_port (), system.logging);
	config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
	auto & node = *system.add_node (config, flags);

	nano::keypair key;
	nano::state_block_builder builder;
	auto send = builder.make_block ()
				.account (nano::dev::genesis_key.pub)
				.previous (nano::dev::genesis->hash ())
				.representative (nano::dev::genesis_key.pub)
				.link (key.pub)
				.balance (nano::dev::constants.genesis_amount - 1)
				.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				.work (*system.work.generate (nano::dev::genesis->hash ()))
				.build_shared ();
	auto send2 = builder.make_block ()
				 .account (nano::dev::genesis_key.pub)
				 .previous (send->hash ())
				 .representative (nano::dev::genesis_key.pub)
				 .link (nano::keypair ().pub)
				 .balance (nano::dev::constants.genesis_amount - 2)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (send->hash ()))
				 .build_shared ();
	auto open = builder.make_block ()
				.account (key.pub)
				.previous (0)
				.representative (key.pub)
				.link (send->hash ())
				.balance (1)
				.sign (key.prv, key.pub)
				.work (*system.work.generate (key.pub))
				.build_shared ();

	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
	ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
	ASSERT_EQ (nano::process_result::progress, node.process (*open).code);

	node.block_confirm (send2);
	auto election = node.active.election (send2->qualified_root ());
	ASSERT_NE (nullptr, election);
	election->force_confirm ();

	ASSERT_TIMELY (3s, !node.confirmation_height_processor.is_processing_added_block (send2->hash ()));
	ASSERT_TRUE (node.block_confirmed (send2->hash ()));
	ASSERT_TRUE (node.block_confirmed (send->hash ()));

	ASSERT_EQ (1, node.stats.count (nano::stat::type::confirmation_observer, nano::stat::detail::inactive_conf_height, nano::stat::dir::out));
	ASSERT_EQ (1, node.stats.count (nano::stat::type::confirmation_observer, nano::stat::detail::active_quorum, nano::stat::dir::out));
	ASSERT_EQ (0, node.stats.count (nano::stat::type::confirmation_observer, nano::stat::detail::active_conf_height, nano::stat::dir::out));

	// The first block was not active so no activation takes place
	ASSERT_FALSE (node.active.active (open->qualified_root ()) || node.block_confirmed_or_being_confirmed (node.store.tx_begin_read (), open->hash ()));
}

namespace nano
{
TEST (active_transactions, pessimistic_elections)
{
	nano::system system;
	nano::node_flags flags;
	nano::node_config config (nano::get_available_port (), system.logging);
	config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
	auto & node = *system.add_node (config, flags);

	nano::keypair key;
	nano::state_block_builder builder;
	auto send = builder.make_block ()
				.account (nano::dev::genesis_key.pub)
				.previous (nano::dev::genesis->hash ())
				.representative (nano::dev::genesis_key.pub)
				.link (nano::dev::genesis_key.pub)
				.balance (nano::dev::constants.genesis_amount - 1)
				.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				.work (*system.work.generate (nano::dev::genesis->hash ()))
				.build_shared ();

	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);

	auto send2 = builder.make_block ()
				 .account (nano::dev::genesis_key.pub)
				 .previous (send->hash ())
				 .representative (nano::dev::genesis_key.pub)
				 .link (key.pub)
				 .balance (nano::dev::constants.genesis_amount - 2)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (send->hash ()))
				 .build ();

	ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);

	auto open = builder.make_block ()
				.account (key.pub)
				.previous (0)
				.representative (key.pub)
				.link (send2->hash ())
				.balance (1)
				.sign (key.prv, key.pub)
				.work (*system.work.generate (key.pub))
				.build_shared ();

	ASSERT_EQ (nano::process_result::progress, node.process (*open).code);

	// This should only cement the first block in genesis account
	uint64_t election_count = 0;
	// Make dummy election with winner.
	{
		nano::election election1 (
		node, send, [] (auto const &) {}, [] (auto const &) {}, nano::election_behavior::normal);
		nano::election election2 (
		node, open, [] (auto const &) {}, [] (auto const &) {}, nano::election_behavior::normal);
		node.active.add_expired_optimistic_election (election1);
		node.active.add_expired_optimistic_election (election2);
	}
	node.active.confirm_expired_frontiers_pessimistically (node.store.tx_begin_read (), 100, election_count);
	ASSERT_EQ (1, election_count);
	ASSERT_EQ (2, node.active.expired_optimistic_election_infos.size ());
	ASSERT_EQ (2, node.active.expired_optimistic_election_infos.size ());
	auto election_started_it = node.active.expired_optimistic_election_infos.get<nano::active_transactions::tag_election_started> ().begin ();
	ASSERT_EQ (election_started_it->account, nano::dev::genesis->account ());
	ASSERT_EQ (election_started_it->election_started, true);
	ASSERT_EQ ((++election_started_it)->election_started, false);

	// No new elections should get started yet
	node.active.confirm_expired_frontiers_pessimistically (node.store.tx_begin_read (), 100, election_count);
	ASSERT_EQ (1, election_count);
	ASSERT_EQ (2, node.active.expired_optimistic_election_infos.size ());
	ASSERT_EQ (node.active.expired_optimistic_election_infos_size, node.active.expired_optimistic_election_infos.size ());

	ASSERT_EQ (1, node.active.size ());
	auto election = node.active.election (send->qualified_root ());
	ASSERT_NE (nullptr, election);
	election->force_confirm ();

	ASSERT_TIMELY (3s, node.block_confirmed (send->hash ()) && !node.confirmation_height_processor.is_processing_added_block (send->hash ()));

	nano::confirmation_height_info genesis_confirmation_height_info;
	nano::confirmation_height_info key1_confirmation_height_info;
	{
		auto transaction = node.store.tx_begin_read ();
		node.store.confirmation_height.get (transaction, nano::dev::genesis->account (), genesis_confirmation_height_info);
		ASSERT_EQ (2, genesis_confirmation_height_info.height);
		node.store.confirmation_height.get (transaction, key.pub, key1_confirmation_height_info);
		ASSERT_EQ (0, key1_confirmation_height_info.height);
	}

	// Activation of cemented frontier successor should get started after the first pessimistic block is confirmed
	ASSERT_TIMELY (10s, node.active.active (send2->qualified_root ()));

	node.active.confirm_expired_frontiers_pessimistically (node.store.tx_begin_read (), 100, election_count);
	ASSERT_EQ (1, election_count);
	ASSERT_EQ (2, node.active.expired_optimistic_election_infos.size ());

	// Confirm it
	election = node.active.election (send2->qualified_root ());
	ASSERT_NE (nullptr, election);
	election->force_confirm ();

	ASSERT_TIMELY (3s, node.block_confirmed (send2->hash ()));

	{
		auto transaction = node.store.tx_begin_read ();
		node.store.confirmation_height.get (transaction, nano::dev::genesis->account (), genesis_confirmation_height_info);
		ASSERT_EQ (3, genesis_confirmation_height_info.height);
		node.store.confirmation_height.get (transaction, key.pub, key1_confirmation_height_info);
		ASSERT_EQ (0, key1_confirmation_height_info.height);
	}

	// Wait until activation of destination account is done.
	ASSERT_TIMELY (10s, node.active.active (open->qualified_root ()));

	// Election count should not increase, but the elections should be marked as started for that account afterwards
	ASSERT_EQ (election_started_it->election_started, false);
	node.active.confirm_expired_frontiers_pessimistically (node.store.tx_begin_read (), 100, election_count);
	ASSERT_EQ (1, election_count);
	ASSERT_EQ (2, node.active.expired_optimistic_election_infos.size ());
	node.active.confirm_expired_frontiers_pessimistically (node.store.tx_begin_read (), 100, election_count);

	election = node.active.election (open->qualified_root ());
	ASSERT_NE (nullptr, election);
	election->force_confirm ();

	ASSERT_TIMELY (3s, node.block_confirmed (open->hash ()));

	{
		auto transaction = node.store.tx_begin_read ();
		node.store.confirmation_height.get (transaction, nano::dev::genesis->account (), genesis_confirmation_height_info);
		ASSERT_EQ (3, genesis_confirmation_height_info.height);
		node.store.confirmation_height.get (transaction, key.pub, key1_confirmation_height_info);
		ASSERT_EQ (1, key1_confirmation_height_info.height);
	}

	// Sanity check that calling it again on a fully cemented chain has no adverse effects.
	node.active.confirm_expired_frontiers_pessimistically (node.store.tx_begin_read (), 100, election_count);
	ASSERT_EQ (1, election_count);
	ASSERT_EQ (2, node.active.expired_optimistic_election_infos.size ());
}
}

TEST (active_transactions, list_active)
{
	nano::system system (1);
	auto & node = *system.nodes[0];

	nano::keypair key;
	nano::state_block_builder builder;
	auto send = builder.make_block ()
				.account (nano::dev::genesis_key.pub)
				.previous (nano::dev::genesis->hash ())
				.representative (nano::dev::genesis_key.pub)
				.link (nano::dev::genesis_key.pub)
				.balance (nano::dev::constants.genesis_amount - 1)
				.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				.work (*system.work.generate (nano::dev::genesis->hash ()))
				.build_shared ();

	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);

	auto send2 = builder.make_block ()
				 .account (nano::dev::genesis_key.pub)
				 .previous (send->hash ())
				 .representative (nano::dev::genesis_key.pub)
				 .link (key.pub)
				 .balance (nano::dev::constants.genesis_amount - 2)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (send->hash ()))
				 .build_shared ();

	ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);

	auto open = builder.make_block ()
				.account (key.pub)
				.previous (0)
				.representative (key.pub)
				.link (send2->hash ())
				.balance (1)
				.sign (key.prv, key.pub)
				.work (*system.work.generate (key.pub))
				.build_shared ();

	ASSERT_EQ (nano::process_result::progress, node.process (*open).code);

	nano::blocks_confirm (node, { send, send2, open });
	ASSERT_EQ (3, node.active.size ());
	ASSERT_EQ (1, node.active.list_active (1).size ());
	ASSERT_EQ (2, node.active.list_active (2).size ());
	ASSERT_EQ (3, node.active.list_active (3).size ());
	ASSERT_EQ (3, node.active.list_active (4).size ());
	ASSERT_EQ (3, node.active.list_active (99999).size ());
	ASSERT_EQ (3, node.active.list_active ().size ());

	auto active = node.active.list_active ();
}

TEST (active_transactions, vacancy)
{
	nano::system system;
	nano::node_config config{ nano::get_available_port (), system.logging };
	config.active_elections_size = 1;
	auto & node = *system.add_node (config);
	nano::state_block_builder builder;
	auto send = builder.make_block ()
				.account (nano::dev::genesis_key.pub)
				.previous (nano::dev::genesis->hash ())
				.representative (nano::dev::genesis_key.pub)
				.link (nano::dev::genesis_key.pub)
				.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
				.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				.work (*system.work.generate (nano::dev::genesis->hash ()))
				.build_shared ();
	std::atomic<bool> updated = false;
	node.active.vacancy_update = [&updated] () { updated = true; };
	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
	ASSERT_EQ (1, node.active.vacancy ());
	ASSERT_EQ (0, node.active.size ());
	node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
	ASSERT_TIMELY (1s, updated);
	updated = false;
	ASSERT_EQ (0, node.active.vacancy ());
	ASSERT_EQ (1, node.active.size ());
	auto election1 = node.active.election (send->qualified_root ());
	ASSERT_NE (nullptr, election1);
	election1->force_confirm ();
	ASSERT_TIMELY (1s, updated);
	ASSERT_EQ (1, node.active.vacancy ());
	ASSERT_EQ (0, node.active.size ());
}

// Ensure transactions in excess of capacity are removed in fifo order
TEST (active_transactions, fifo)
{
	nano::system system;
	nano::node_config config{ nano::get_available_port (), system.logging };
	config.active_elections_size = 1;
	auto & node = *system.add_node (config);
	nano::keypair key0;
	nano::keypair key1;
	nano::state_block_builder builder;
	// Construct two pending entries that can be received simultaneously
	auto send0 = builder.make_block ()
				 .account (nano::dev::genesis_key.pub)
				 .previous (nano::dev::genesis->hash ())
				 .representative (nano::dev::genesis_key.pub)
				 .link (key0.pub)
				 .balance (nano::dev::constants.genesis_amount - 1)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (nano::dev::genesis->hash ()))
				 .build_shared ();
	ASSERT_EQ (nano::process_result::progress, node.process (*send0).code);
	nano::blocks_confirm (node, { send0 }, true);
	ASSERT_TIMELY (1s, node.block_confirmed (send0->hash ()));
	ASSERT_TIMELY (1s, node.active.empty ());
	auto send1 = builder.make_block ()
				 .account (nano::dev::genesis_key.pub)
				 .previous (send0->hash ())
				 .representative (nano::dev::genesis_key.pub)
				 .link (key1.pub)
				 .balance (nano::dev::constants.genesis_amount - 2)
				 .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
				 .work (*system.work.generate (send0->hash ()))
				 .build_shared ();
	ASSERT_EQ (nano::process_result::progress, node.process (*send1).code);
	nano::blocks_confirm (node, { send1 }, true);
	ASSERT_TIMELY (1s, node.block_confirmed (send1->hash ()));
	ASSERT_TIMELY (1s, node.active.empty ());

	auto receive0 = builder.make_block ()
					.account (key0.pub)
					.previous (0)
					.representative (nano::dev::genesis_key.pub)
					.link (send0->hash ())
					.balance (1)
					.sign (key0.prv, key0.pub)
					.work (*system.work.generate (key0.pub))
					.build_shared ();
	ASSERT_EQ (nano::process_result::progress, node.process (*receive0).code);
	auto receive1 = builder.make_block ()
					.account (key1.pub)
					.previous (0)
					.representative (nano::dev::genesis_key.pub)
					.link (send1->hash ())
					.balance (1)
					.sign (key1.prv, key1.pub)
					.work (*system.work.generate (key1.pub))
					.build_shared ();
	ASSERT_EQ (nano::process_result::progress, node.process (*receive1).code);
	node.scheduler.manual (receive0);
	// Ensure first transaction becomes active
	ASSERT_TIMELY (1s, node.active.election (receive0->qualified_root ()) != nullptr);
	node.scheduler.manual (receive1);
	// Ensure second transaction becomes active
	ASSERT_TIMELY (1s, node.active.election (receive1->qualified_root ()) != nullptr);
	// Ensure excess transactions get trimmed
	ASSERT_TIMELY (1s, node.active.size () == 1);
	// Ensure overflow stats have been incremented
	ASSERT_EQ (1, node.stats.count (nano::stat::type::election, nano::stat::detail::election_drop_overflow));
	// Ensure the surviving transaction is the least recently inserted
	ASSERT_TIMELY (1s, node.active.election (receive1->qualified_root ()) != nullptr);
}
",16339,True,3836.819205433614,median
"// Copyright (c) 2017-2018, The Monero Project
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
// 
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS"" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//

#include ""device_ledger.hpp""
#include ""log.hpp""
#include ""ringct/rctOps.h""
#include ""cryptonote_basic/account.h""
#include ""cryptonote_basic/subaddress_index.h""

#include <boost/thread/locks.hpp> 
#include <boost/thread/lock_guard.hpp>

namespace hw {

  namespace ledger {

  #ifdef WITH_DEVICE_LEDGER

    #undef MONERO_DEFAULT_LOG_CATEGORY
    #define MONERO_DEFAULT_LOG_CATEGORY ""device.ledger""

    /* ===================================================================== */
    /* ===                           Debug                              ==== */
    /* ===================================================================== */
    #ifdef WIN32
    static char *pcsc_stringify_error(LONG rv) {
     static __thread char out[20];
     sprintf_s(out, sizeof(out), ""0x%08lX"", rv);

     return out;
    }
    #endif

    void set_apdu_verbose(bool verbose) {
      apdu_verbose = verbose;
    }

    #define TRACKD MTRACE(""hw"")
    #define ASSERT_RV(rv)        CHECK_AND_ASSERT_THROW_MES((rv)==SCARD_S_SUCCESS, ""Fail SCard API : ("" << (rv) << "") ""<< pcsc_stringify_error(rv)<<"" Device=""<<this->id<<"", hCard=""<<hCard<<"", hContext=""<<hContext);
    #define ASSERT_SW(sw,ok,msk) CHECK_AND_ASSERT_THROW_MES(((sw)&(mask))==(ok), ""Wrong Device Status : SW="" << std::hex << (sw) << "" (EXPECT="" << std::hex << (ok) << "", MASK="" << std::hex << (mask) << "")"") ;
    #define ASSERT_T0(exp)       CHECK_AND_ASSERT_THROW_MES(exp, ""Protocol assert failure: ""#exp ) ;
    #define ASSERT_X(exp,msg)    CHECK_AND_ASSERT_THROW_MES(exp, msg); 

    #ifdef DEBUG_HWDEVICE
      crypto::secret_key dbg_viewkey;
      crypto::secret_key dbg_spendkey;
    #endif

    /* ===================================================================== */
    /* ===                        Keymap                                ==== */
    /* ===================================================================== */

    ABPkeys::ABPkeys(const rct::key& A, const rct::key& B, const bool is_subaddr, const size_t real_output_index, const rct::key& P, const rct::key& AK) {
      Aout = A;
      Bout = B;
      is_subaddress = is_subaddr;
      index = real_output_index;
      Pout = P;
      AKout = AK;
    }

    ABPkeys::ABPkeys(const ABPkeys& keys) {
      Aout = keys.Aout;
      Bout = keys.Bout;
      is_subaddress = keys.is_subaddress;
      index = keys.index;
      Pout = keys.Pout;
      AKout = keys.AKout;
    }

    bool Keymap::find(const rct::key& P, ABPkeys& keys) const {
      size_t sz = ABP.size();
      for (size_t i=0; i<sz; i++) {
        if (ABP[i].Pout == P) {
          keys = ABP[i];
          return true;
        }
      }
      return false;
    }

    void Keymap::add(const ABPkeys& keys) {
      ABP.push_back(keys);
    }

    void Keymap::clear() {
      ABP.clear();
    }

    #ifdef DEBUG_HWDEVICE
    void Keymap::log() {
      log_message(""keymap"", ""content"");
      size_t sz = ABP.size();
      for (size_t i=0; i<sz; i++) {
        log_message(""  keymap"", std::to_string(i));
        log_hexbuffer(""    Aout"", (char*)ABP[i].Aout.bytes, 32);
        log_hexbuffer(""    Bout"", (char*)ABP[i].Bout.bytes, 32);
        log_message  (""  is_sub"", std::to_string(ABP[i].is_subaddress));
        log_message  (""   index"", std::to_string(ABP[i].index));
        log_hexbuffer(""    Pout"", (char*)ABP[i].Pout.bytes, 32);
      }
    }
    #endif

    /* ===================================================================== */
    /* ===                       Internal Helpers                       ==== */
    /* ===================================================================== */
    static bool is_fake_view_key(const crypto::secret_key &sec) {
      return sec == crypto::null_skey;
    }

    bool operator==(const crypto::key_derivation &d0, const crypto::key_derivation &d1) {
      return !memcmp(&d0, &d1, sizeof(d0));
    }

    /* ===================================================================== */
    /* ===                             Device                           ==== */
    /* ===================================================================== */

    static int device_id = 0;

    #define INS_NONE                            0x00
    #define INS_RESET                           0x02

    #define INS_GET_KEY                         0x20
    #define INS_PUT_KEY                         0x22
    #define INS_GET_CHACHA8_PREKEY              0x24
    #define INS_VERIFY_KEY                      0x26

    #define INS_SECRET_KEY_TO_PUBLIC_KEY        0x30
    #define INS_GEN_KEY_DERIVATION              0x32
    #define INS_DERIVATION_TO_SCALAR            0x34
    #define INS_DERIVE_PUBLIC_KEY               0x36
    #define INS_DERIVE_SECRET_KEY               0x38
    #define INS_GEN_KEY_IMAGE                   0x3A
    #define INS_SECRET_KEY_ADD                  0x3C
    #define INS_SECRET_KEY_SUB                  0x3E
    #define INS_GENERATE_KEYPAIR                0x40
    #define INS_SECRET_SCAL_MUL_KEY             0x42
    #define INS_SECRET_SCAL_MUL_BASE            0x44

    #define INS_DERIVE_SUBADDRESS_PUBLIC_KEY    0x46
    #define INS_GET_SUBADDRESS                  0x48
    #define INS_GET_SUBADDRESS_SPEND_PUBLIC_KEY 0x4A
    #define INS_GET_SUBADDRESS_SECRET_KEY       0x4C

    #define INS_OPEN_TX                         0x70
    #define INS_SET_SIGNATURE_MODE              0x72
    #define INS_GET_ADDITIONAL_KEY              0x74
    #define INS_STEALTH                         0x76
    #define INS_BLIND                           0x78
    #define INS_UNBLIND                         0x7A
    #define INS_VALIDATE                        0x7C
    #define INS_MLSAG                           0x7E
    #define INS_CLOSE_TX                        0x80


    #define INS_GET_RESPONSE                    0xc0


    void device_ledger::logCMD() {
      if (apdu_verbose) {
        char  strbuffer[1024];
        snprintf(strbuffer, sizeof(strbuffer), ""%.02x %.02x %.02x %.02x %.02x "",
          this->buffer_send[0],
          this->buffer_send[1],
          this->buffer_send[2],
          this->buffer_send[3],
          this->buffer_send[4]
          );
        const size_t len = strlen(strbuffer);
        buffer_to_str(strbuffer+len, sizeof(strbuffer)-len, (char*)(this->buffer_send+5), this->length_send-5);
        MDEBUG( ""CMD  :"" << strbuffer);
      }
    }

    void device_ledger::logRESP() {
      if (apdu_verbose) {
        char  strbuffer[1024];
        snprintf(strbuffer, sizeof(strbuffer), ""%.02x%.02x "",
          this->buffer_recv[this->length_recv-2],
          this->buffer_recv[this->length_recv-1]
          );
        const size_t len = strlen(strbuffer);
        buffer_to_str(strbuffer+len, sizeof(strbuffer)-len, (char*)(this->buffer_recv), this->length_recv-2);
        MDEBUG( ""RESP :"" << strbuffer);

      }
    }

    /* -------------------------------------------------------------- */
    device_ledger::device_ledger() {
      this->id = device_id++;
      this->hCard   = 0;
      this->hContext = 0;
      this->reset_buffer();      
      this->mode = NONE;
      this->has_view_key = false;
      MDEBUG( ""Device ""<<this->id <<"" Created"");
    }

    device_ledger::~device_ledger() {
      this->release();
      MDEBUG( ""Device ""<<this->id <<"" Destroyed"");
    }

    /* ======================================================================= */
    /*  LOCKER                                                                 */
    /* ======================================================================= */ 
    
    //automatic lock one more level on device ensuring the current thread is allowed to use it
    #define AUTO_LOCK_CMD() \\
      /* lock both mutexes without deadlock*/ \\
      boost::lock(device_locker, command_locker); \\
      /* make sure both already-locked mutexes are unlocked at the end of scope */ \\
      boost::lock_guard<boost::recursive_mutex> lock1(device_locker, boost::adopt_lock); \\
      boost::lock_guard<boost::mutex> lock2(command_locker, boost::adopt_lock)

    //lock the device for a long sequence
    void device_ledger::lock(void) {
      MDEBUG( ""Ask for LOCKING for device ""<<this->name << "" in thread "");
      device_locker.lock();
      MDEBUG( ""Device ""<<this->name << "" LOCKed"");
    }

    //lock the device for a long sequence
    bool device_ledger::try_lock(void) {
      MDEBUG( ""Ask for LOCKING(try) for device ""<<this->name << "" in thread "");
      bool r = device_locker.try_lock();
      if (r) {
        MDEBUG( ""Device ""<<this->name << "" LOCKed(try)"");
      } else {
        MDEBUG( ""Device ""<<this->name << "" not LOCKed(try)"");
      }
      return r;
    }

    //lock the device for a long sequence
    void device_ledger::unlock(void) {
      try {
        MDEBUG( ""Ask for UNLOCKING for device ""<<this->name << "" in thread "");
      } catch (...) {
      }
      device_locker.unlock();
      MDEBUG( ""Device ""<<this->name << "" UNLOCKed"");
    }

    /* ======================================================================= */
    /*                                   MISC                                  */
    /* ======================================================================= */
    int device_ledger::set_command_header(BYTE ins, BYTE p1, BYTE p2) {
      reset_buffer();
      int offset = 0;
      this->buffer_send[0] = 0x00;
      this->buffer_send[1] = ins;
      this->buffer_send[2] = p1;
      this->buffer_send[3] = p2;
      this->buffer_send[4] = 0x00;
      return 5;
    }

    int device_ledger::set_command_header_noopt(BYTE ins, BYTE p1, BYTE p2) {
      int offset = set_command_header(ins, p1, p2);
      //options
      this->buffer_send[offset++] = 0;
      this->buffer_send[4] = offset - 5;
      return offset;
    }

    void device_ledger::send_simple(BYTE ins, BYTE p1) {
      this->length_send = set_command_header_noopt(ins, p1);
      this->exchange();
    }

    bool device_ledger::reset() {
        send_simple(INS_RESET);
        return true;
    }
     
    unsigned int device_ledger::exchange(unsigned int ok, unsigned int mask) {
      LONG rv;
      unsigned int sw;

      ASSERT_T0(this->length_send <= BUFFER_SEND_SIZE);
      logCMD();
      this->length_recv = BUFFER_RECV_SIZE;
      rv = SCardTransmit(this->hCard,
                         SCARD_PCI_T0, this->buffer_send, this->length_send,
                         NULL,         this->buffer_recv, &this->length_recv);
      ASSERT_RV(rv);
      ASSERT_T0(this->length_recv >= 2);
      ASSERT_T0(this->length_recv <= BUFFER_RECV_SIZE);
      logRESP();

      sw = (this->buffer_recv[this->length_recv-2]<<8) | this->buffer_recv[this->length_recv-1];
      ASSERT_SW(sw,ok,msk);
      return sw;
    }

    void device_ledger::reset_buffer() {
      this->length_send = 0;
      memset(this->buffer_send, 0, BUFFER_SEND_SIZE);
      this->length_recv = 0;
      memset(this->buffer_recv, 0, BUFFER_RECV_SIZE);
    }

    /* ======================================================================= */
    /*                              SETUP/TEARDOWN                             */
    /* ======================================================================= */

    bool device_ledger::set_name(const std::string & name) {
      this->name = name;
      return true;
    }

    const std::string device_ledger::get_name() const {
      if (this->full_name.empty() || (this->hCard == 0)) {
        return std::string(""<disconnected:"").append(this->name).append("">"");
      }
      return this->full_name;
    }

    bool device_ledger::init(void) {
      #ifdef DEBUG_HWDEVICE
      this->controle_device = &hw::get_device(""default"");
      #endif
      LONG  rv;
      this->release();
      rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM,0,0, &this->hContext);
      ASSERT_RV(rv);
      MDEBUG( ""Device ""<<this->id <<"" SCardContext created: hContext=""<<this->hContext);
      this->hCard = 0;
      return true;
    }

    bool device_ledger::release() {
      this->disconnect();
      if (this->hContext) {
        SCardReleaseContext(this->hContext);
        MDEBUG( ""Device ""<<this->id <<"" SCardContext released: hContext=""<<this->hContext);
        this->hContext = 0;
        this->full_name.clear();
      }
      return true;
    }

    bool device_ledger::connect(void) {
      BYTE  pbAtr[MAX_ATR_SIZE];
      LPSTR mszReaders;
      DWORD dwReaders;
      LONG  rv;
      DWORD dwState, dwProtocol, dwAtrLen, dwReaderLen;

      this->disconnect();
#ifdef SCARD_AUTOALLOCATE
      dwReaders = SCARD_AUTOALLOCATE;
      rv = SCardListReaders(this->hContext, NULL, (LPSTR)&mszReaders, &dwReaders);
#else
      dwReaders = 0;
      rv = SCardListReaders(this->hContext, NULL, NULL, &dwReaders);
      if (rv != SCARD_S_SUCCESS)
        return false;
      mszReaders = (LPSTR)calloc(dwReaders, sizeof(char));
      rv = SCardListReaders(this->hContext, NULL, mszReaders, &dwReaders);
#endif
      if (rv == SCARD_S_SUCCESS) {
        char* p;
        const char* prefix = this->name.c_str();

        p = mszReaders;
        MDEBUG( ""Looking for "" << std::string(prefix));
        while (*p) {
          MDEBUG( ""Device Found: "" <<  std::string(p));
          if ((strncmp(prefix, p, strlen(prefix))==0)) {
            MDEBUG( ""Device Match: "" <<  std::string(p));
            if ((rv = SCardConnect(this->hContext,
                                   p, SCARD_SHARE_EXCLUSIVE, SCARD_PROTOCOL_T0,
                                   &this->hCard, &dwProtocol))!=SCARD_S_SUCCESS) {
              break;
            }
            MDEBUG( ""Device ""<<this->id <<"" Connected: hCard=""<<this->hCard);
            dwAtrLen = sizeof(pbAtr);
            if ((rv = SCardStatus(this->hCard, NULL, &dwReaderLen, &dwState, &dwProtocol, pbAtr, &dwAtrLen))!=SCARD_S_SUCCESS) {
              break;
            }
            MDEBUG( ""Device ""<<this->id <<"" Status OK"");
            rv = SCARD_S_SUCCESS ;
            this->full_name = std::string(p);
            break;
          }
          p += strlen(p) +1;
        }
      }

      if (rv == SCARD_S_SUCCESS && mszReaders) {
        #ifdef SCARD_AUTOALLOCATE
        SCardFreeMemory(this->hContext, mszReaders);
        #else
        free(mszReaders);
        #endif
        mszReaders = NULL;
      }
      if (rv != SCARD_S_SUCCESS) {
        if ( hCard) {
          SCardDisconnect(this->hCard, SCARD_UNPOWER_CARD);
          MDEBUG( ""Device ""<<this->id <<"" disconnected: hCard=""<<this->hCard);
          this->hCard = 0;
        }
      }
      ASSERT_RV(rv);

      this->reset();
      #ifdef DEBUG_HWDEVICE
      cryptonote::account_public_address pubkey;
      this->get_public_address(pubkey);
      #endif
      crypto::secret_key vkey;
      crypto::secret_key skey;
      this->get_secret_keys(vkey,skey);

      return rv==SCARD_S_SUCCESS;
    }

    bool device_ledger::disconnect() {
      if (this->hCard) {
        SCardDisconnect(this->hCard, SCARD_UNPOWER_CARD);
        MDEBUG( ""Device ""<<this->id <<"" disconnected: hCard=""<<this->hCard); 
        this->hCard = 0;
      }
      return true;
    }

    bool  device_ledger::set_mode(device_mode mode) {
        AUTO_LOCK_CMD();

        int offset;

        switch(mode) {
        case TRANSACTION_CREATE_REAL:
        case TRANSACTION_CREATE_FAKE:
          offset = set_command_header_noopt(INS_SET_SIGNATURE_MODE, 1);
          //account
          this->buffer_send[offset] = mode;
          offset += 1;

          this->buffer_send[4] = offset-5;
          this->length_send = offset;
          this->exchange();

          this->mode = mode;
          break;

        case TRANSACTION_PARSE: 
        case NONE:
          this->mode = mode;
          break;
        default:
           CHECK_AND_ASSERT_THROW_MES(false, "" device_ledger::set_mode(unsigned int mode): invalid mode: ""<<mode);
        }
        MDEBUG(""Switch to mode: "" <<mode);
        return true;
    }


    /* ======================================================================= */
    /*                             WALLET & ADDRESS                            */
    /* ======================================================================= */

     bool device_ledger::get_public_address(cryptonote::account_public_address &pubkey){
        AUTO_LOCK_CMD();

        send_simple(INS_GET_KEY, 1);

        memmove(pubkey.m_view_public_key.data, this->buffer_recv, 32);
        memmove(pubkey.m_spend_public_key.data, this->buffer_recv+32, 32);
 
        return true;
    }

    bool  device_ledger::get_secret_keys(crypto::secret_key &vkey , crypto::secret_key &skey) {
        AUTO_LOCK_CMD();

        //secret key are represented as fake key on the wallet side
        memset(vkey.data, 0x00, 32);
        memset(skey.data, 0xFF, 32);

        //spcialkey, normal conf handled in decrypt
        send_simple(INS_GET_KEY, 0x02);

        //View key is retrievied, if allowed, to speed up blockchain parsing
        memmove(this->viewkey.data,  this->buffer_recv+0,  32);
        if (is_fake_view_key(this->viewkey)) {
          MDEBUG(""Have Not view key"");
          this->has_view_key = false;
        } else {
          MDEBUG(""Have view key"");
          this->has_view_key = true;
        }
      
        #ifdef DEBUG_HWDEVICE
        memmove(dbg_viewkey.data, this->buffer_recv+0, 32);
        memmove(dbg_spendkey.data, this->buffer_recv+32, 32);
        #endif

        return true;
    }

    bool  device_ledger::generate_chacha_key(const cryptonote::account_keys &keys, crypto::chacha_key &key) {
        AUTO_LOCK_CMD();

        #ifdef DEBUG_HWDEVICE
        crypto::chacha_key key_x;
        cryptonote::account_keys keys_x = hw::ledger::decrypt(keys); 
        this->controle_device->generate_chacha_key(keys_x, key_x);
        #endif

        send_simple(INS_GET_CHACHA8_PREKEY);

        char prekey[200];
        memmove(prekey, &this->buffer_recv[0], 200);
        crypto::generate_chacha_key_prehashed(&prekey[0], sizeof(prekey), key);

        #ifdef DEBUG_HWDEVICE
        hw::ledger::check32(""generate_chacha_key_prehashed"", ""key"", (char*)key_x.data(), (char*)key.data());
        #endif

      return true;
    }

    /* ======================================================================= */
    /*                               SUB ADDRESS                               */
    /* ======================================================================= */

    bool device_ledger::derive_subaddress_public_key(const crypto::public_key &pub, const crypto::key_derivation &derivation, const std::size_t output_index, crypto::public_key &derived_pub){
        AUTO_LOCK_CMD();
        #ifdef DEBUG_HWDEVICE
        const crypto::public_key pub_x = pub;
        crypto::key_derivation derivation_x;
         if ((this->mode == TRANSACTION_PARSE) && has_view_key) {    
          derivation_x = derivation;
        } else {
          derivation_x = hw::ledger::decrypt(derivation);
        }
        const std::size_t output_index_x = output_index;
        crypto::public_key derived_pub_x;
        hw::ledger::log_hexbuffer(""derive_subaddress_public_key: [[IN]]  pub       "", pub_x.data, 32);
        hw::ledger::log_hexbuffer(""derive_subaddress_public_key: [[IN]]  derivation"", derivation_x.data, 32);
        hw::ledger::log_message  (""derive_subaddress_public_key: [[IN]]  index     "", std::to_string((int)output_index_x));
        this->controle_device->derive_subaddress_public_key(pub_x, derivation_x,output_index_x,derived_pub_x);
        hw::ledger::log_hexbuffer(""derive_subaddress_public_key: [[OUT]] derived_pub"", derived_pub_x.data, 32);
        #endif

      if ((this->mode == TRANSACTION_PARSE) && has_view_key) {     
        //If we are in TRANSACTION_PARSE, the given derivation has been retrieved uncrypted (wihtout the help
        //of the device), so continue that way.
        MDEBUG( ""derive_subaddress_public_key  : PARSE mode with known viewkey"");     
        crypto::derive_subaddress_public_key(pub, derivation, output_index,derived_pub);
      } else {
       
        int offset = set_command_header_noopt(INS_DERIVE_SUBADDRESS_PUBLIC_KEY);
        //pub
        memmove(this->buffer_send+offset, pub.data, 32);
        offset += 32;
        //derivation
        memmove(this->buffer_send+offset, derivation.data, 32);
        offset += 32;
        //index
        this->buffer_send[offset+0] = output_index>>24;
        this->buffer_send[offset+1] = output_index>>16;
        this->buffer_send[offset+2] = output_index>>8;
        this->buffer_send[offset+3] = output_index>>0;
        offset += 4;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        //pub key
        memmove(derived_pub.data, &this->buffer_recv[0], 32);
      }
      #ifdef DEBUG_HWDEVICE
      hw::ledger::check32(""derive_subaddress_public_key"", ""derived_pub"", derived_pub_x.data, derived_pub.data);
      #endif

      return true;
    }

    crypto::public_key device_ledger::get_subaddress_spend_public_key(const cryptonote::account_keys& keys, const cryptonote::subaddress_index &index) {
        AUTO_LOCK_CMD();
        crypto::public_key D;

        #ifdef DEBUG_HWDEVICE
        const cryptonote::account_keys     keys_x =  hw::ledger::decrypt(keys);
        const cryptonote::subaddress_index index_x = index;
        crypto::public_key                 D_x;
        hw::ledger::log_hexbuffer(""get_subaddress_spend_public_key: [[IN]]  keys.m_view_secret_key "", keys_x.m_view_secret_key.data,32);
        hw::ledger::log_hexbuffer(""get_subaddress_spend_public_key: [[IN]]  keys.m_spend_secret_key"", keys_x.m_spend_secret_key.data,32);
        hw::ledger::log_message  (""get_subaddress_spend_public_key: [[IN]]  index               "", std::to_string(index_x.major)+"".""+std::to_string(index_x.minor));
        D_x = this->controle_device->get_subaddress_spend_public_key(keys_x, index_x);
        hw::ledger::log_hexbuffer(""get_subaddress_spend_public_key: [[OUT]] derivation          "", D_x.data, 32);
        #endif

        if (index.is_zero()) {
           D = keys.m_account_address.m_spend_public_key;
        } else {

          int offset = set_command_header_noopt(INS_GET_SUBADDRESS_SPEND_PUBLIC_KEY);
          //index
          static_assert(sizeof(cryptonote::subaddress_index) == 8, ""cryptonote::subaddress_index shall be 8 bytes length"");
          memmove(this->buffer_send+offset, &index, sizeof(cryptonote::subaddress_index));
          offset +=8 ;

          this->buffer_send[4] = offset-5;
          this->length_send = offset;
          this->exchange();

          memmove(D.data, &this->buffer_recv[0], 32);
        }

        #ifdef DEBUG_HWDEVICE
        hw::ledger::check32(""get_subaddress_spend_public_key"", ""D"", D_x.data, D.data);
        #endif

        return D;
    }

    std::vector<crypto::public_key>  device_ledger::get_subaddress_spend_public_keys(const cryptonote::account_keys &keys, uint32_t account, uint32_t begin, uint32_t end) {
     std::vector<crypto::public_key> pkeys;
     cryptonote::subaddress_index index = {account, begin};
     crypto::public_key D;
     for (uint32_t idx = begin; idx < end; ++idx) {
        index.minor = idx;
        D = this->get_subaddress_spend_public_key(keys, index);
        pkeys.push_back(D);
      }
      return pkeys;
    }

    cryptonote::account_public_address device_ledger::get_subaddress(const cryptonote::account_keys& keys, const cryptonote::subaddress_index &index) {
        AUTO_LOCK_CMD();
        cryptonote::account_public_address address;

        #ifdef DEBUG_HWDEVICE
        const cryptonote::account_keys            keys_x =  hw::ledger::decrypt(keys);
        const cryptonote::subaddress_index        index_x = index;
        cryptonote::account_public_address  address_x;
        hw::ledger::log_hexbuffer(""get_subaddress: [[IN]]  keys.m_view_secret_key "", keys_x.m_view_secret_key.data, 32);
        hw::ledger::log_hexbuffer(""get_subaddress: [[IN]]  keys.m_view_public_key"",  keys_x.m_account_address.m_view_public_key.data, 32);
        hw::ledger::log_hexbuffer(""get_subaddress: [[IN]]  keys.m_view_secret_key "", keys_x.m_view_secret_key.data, 32);
        hw::ledger::log_hexbuffer(""get_subaddress: [[IN]]  keys.m_spend_public_key"", keys_x.m_account_address.m_spend_public_key.data, 32);
        hw::ledger::log_message  (""get_subaddress: [[IN]]  index                                "", std::to_string(index_x.major)+"".""+std::to_string(index_x.minor));
        address_x = this->controle_device->get_subaddress(keys_x, index_x);
        hw::ledger::log_hexbuffer(""get_subaddress: [[OUT]]  keys.m_view_public_key "", address_x.m_view_public_key.data, 32);
        hw::ledger::log_hexbuffer(""get_subaddress: [[OUT]]  keys.m_spend_public_key"", address_x.m_spend_public_key.data, 32);
        #endif

        if (index.is_zero()) {
          address = keys.m_account_address;
        } else {
          int offset = set_command_header_noopt(INS_GET_SUBADDRESS);
          //index
          static_assert(sizeof(cryptonote::subaddress_index) == 8, ""cryptonote::subaddress_index shall be 8 bytes length"");
          memmove(this->buffer_send+offset, &index, sizeof(cryptonote::subaddress_index));
          offset +=8 ;

          this->buffer_send[4] = offset-5;
          this->length_send = offset;
          this->exchange();

          memmove(address.m_view_public_key.data,  &this->buffer_recv[0],  32);
          memmove(address.m_spend_public_key.data, &this->buffer_recv[32], 32);
        }

        #ifdef DEBUG_HWDEVICE
        hw::ledger::check32(""get_subaddress"", ""address.m_view_public_key.data"", address_x.m_view_public_key.data, address.m_view_public_key.data);
        hw::ledger::check32(""get_subaddress"", ""address.m_spend_public_key.data"", address_x.m_spend_public_key.data, address.m_spend_public_key.data);
        #endif

        return address;
    }

    crypto::secret_key  device_ledger::get_subaddress_secret_key(const crypto::secret_key &sec, const cryptonote::subaddress_index &index) {
        AUTO_LOCK_CMD();
        crypto::secret_key sub_sec;

        #ifdef DEBUG_HWDEVICE
        const crypto::secret_key            sec_x =  hw::ledger::decrypt(sec);
        const cryptonote::subaddress_index  index_x = index;
        crypto::secret_key            sub_sec_x;
        hw::ledger::log_message  (""get_subaddress_secret_key: [[IN]]  index  "", std::to_string(index.major)+"".""+std::to_string(index.minor));
        hw::ledger::log_hexbuffer(""get_subaddress_secret_key: [[IN]]  sec    "", sec_x.data, 32);
        sub_sec_x = this->controle_device->get_subaddress_secret_key(sec_x, index_x);
        hw::ledger::log_hexbuffer(""get_subaddress_secret_key: [[OUT]] sub_sec"", sub_sec_x.data, 32);
        #endif

        int offset = set_command_header_noopt(INS_GET_SUBADDRESS_SECRET_KEY);
        //sec
        memmove(this->buffer_send+offset, sec.data, 32);
        offset += 32;
        //index
        static_assert(sizeof(cryptonote::subaddress_index) == 8, ""cryptonote::subaddress_index shall be 8 bytes length"");
        memmove(this->buffer_send+offset, &index, sizeof(cryptonote::subaddress_index));
        offset +=8 ;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        memmove(sub_sec.data,  &this->buffer_recv[0],  32);

        #ifdef DEBUG_HWDEVICE
        crypto::secret_key            sub_sec_clear =   hw::ledger::decrypt(sub_sec);
        hw::ledger::check32(""get_subaddress_secret_key"", ""sub_sec"", sub_sec_x.data, sub_sec_clear.data);
        #endif

        return sub_sec;
    }

    /* ======================================================================= */
    /*                            DERIVATION & KEY                             */
    /* ======================================================================= */

    bool  device_ledger::verify_keys(const crypto::secret_key &secret_key, const crypto::public_key &public_key) {
        AUTO_LOCK_CMD();
        int offset, sw;

        offset = set_command_header_noopt(INS_VERIFY_KEY);
        //sec
        memmove(this->buffer_send+offset, secret_key.data, 32);
        offset += 32;
        //pub
        memmove(this->buffer_send+offset, public_key.data, 32);
        offset += 32;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        uint32_t verified =
          this->buffer_recv[0] << 24 |
          this->buffer_recv[1] << 16 |
          this->buffer_recv[2] << 8  |
          this->buffer_recv[3] << 0  ;

        return verified == 1;
    }

    bool device_ledger::scalarmultKey(rct::key & aP, const rct::key &P, const rct::key &a) {
        AUTO_LOCK_CMD();

        #ifdef DEBUG_HWDEVICE
        const rct::key P_x    =  P;
        const rct::key a_x    =  hw::ledger::decrypt(a);
        rct::key aP_x;
        hw::ledger::log_hexbuffer(""scalarmultKey: [[IN]]  P "", (char*)P_x.bytes, 32);       
        hw::ledger::log_hexbuffer(""scalarmultKey: [[IN]]  a "", (char*)a_x.bytes, 32);       
        this->controle_device->scalarmultKey(aP_x, P_x, a_x);
        hw::ledger::log_hexbuffer(""scalarmultKey: [[OUT]] aP"", (char*)aP_x.bytes, 32);       
        #endif

        int offset = set_command_header_noopt(INS_SECRET_SCAL_MUL_KEY);
        //pub
        memmove(this->buffer_send+offset, P.bytes, 32);
        offset += 32;
        //sec
        memmove(this->buffer_send+offset, a.bytes, 32);
        offset += 32;


        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        //pub key
        memmove(aP.bytes, &this->buffer_recv[0], 32);

        #ifdef DEBUG_HWDEVICE
        hw::ledger::check32(""scalarmultKey"", ""mulkey"", (char*)aP_x.bytes, (char*)aP.bytes);
        #endif

        return true;
    }

    bool device_ledger::scalarmultBase(rct::key &aG, const rct::key &a) {
        AUTO_LOCK_CMD();

        #ifdef DEBUG_HWDEVICE
        const rct::key a_x    =  hw::ledger::decrypt(a);
        rct::key aG_x;
        hw::ledger::log_hexbuffer(""scalarmultKey: [[IN]]  a "", (char*)a_x.bytes, 32);       
        this->controle_device->scalarmultBase(aG_x, a_x);
        hw::ledger::log_hexbuffer(""scalarmultKey: [[OUT]] aG"", (char*)aG_x.bytes, 32);       
        #endif

        int offset = set_command_header_noopt(INS_SECRET_SCAL_MUL_BASE);
        //sec
        memmove(this->buffer_send+offset, a.bytes, 32);
        offset += 32;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        //pub key
        memmove(aG.bytes, &this->buffer_recv[0], 32);

        #ifdef DEBUG_HWDEVICE
        hw::ledger::check32(""scalarmultBase"", ""mulkey"", (char*)aG_x.bytes, (char*)aG.bytes);
        #endif

        return true;
    }

    bool device_ledger::sc_secret_add( crypto::secret_key &r, const crypto::secret_key &a, const crypto::secret_key &b) {
        AUTO_LOCK_CMD();

        #ifdef DEBUG_HWDEVICE
        const crypto::secret_key a_x = hw::ledger::decrypt(a);
        const crypto::secret_key b_x = hw::ledger::decrypt(b);
        crypto::secret_key r_x;
        this->controle_device->sc_secret_add(r_x, a_x, b_x);
        #endif

        int offset = set_command_header_noopt(INS_SECRET_KEY_ADD);
        //sec key
        memmove(this->buffer_send+offset, a.data, 32);
        offset += 32;
        //sec key
        memmove(this->buffer_send+offset, b.data, 32);
        offset += 32;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        //pub key
        memmove(r.data, &this->buffer_recv[0], 32);

        #ifdef DEBUG_HWDEVICE
        crypto::secret_key r_clear = hw::ledger::decrypt(r);
        hw::ledger::check32(""sc_secret_add"", ""r"", r_x.data, r_clear.data);
        #endif

        return true;
    }

    crypto::secret_key  device_ledger::generate_keys(crypto::public_key &pub, crypto::secret_key &sec, const crypto::secret_key& recovery_key, bool recover) {
        AUTO_LOCK_CMD();
        if (recover) {
           throw std::runtime_error(""device generate key does not support recover"");
        }

        #ifdef DEBUG_HWDEVICE
        bool recover_x = recover;
        const crypto::secret_key recovery_key_x = recovery_key;
        crypto::public_key pub_x;
        crypto::secret_key sec_x;
        #endif

        send_simple(INS_GENERATE_KEYPAIR);

        //pub key
        memmove(pub.data, &this->buffer_recv[0], 32);
        memmove(sec.data, &this->buffer_recv[32], 32);

        #ifdef DEBUG_HWDEVICE
        crypto::secret_key sec_clear = hw::ledger::decrypt(sec);
        sec_x = sec_clear;
        crypto::secret_key_to_public_key(sec_x,pub_x);
        hw::ledger::check32(""generate_keys"", ""pub"", pub_x.data, pub.data);
        #endif

        return sec;

    }

    bool device_ledger::generate_key_derivation(const crypto::public_key &pub, const crypto::secret_key &sec, crypto::key_derivation &derivation) {
        AUTO_LOCK_CMD();
        bool r = false;

        #ifdef DEBUG_HWDEVICE
        const crypto::public_key pub_x = pub;
        const crypto::secret_key sec_x = hw::ledger::decrypt(sec);
        crypto::key_derivation derivation_x;
        hw::ledger::log_hexbuffer(""generate_key_derivation: [[IN]]  pub       "", pub_x.data, 32);
        hw::ledger::log_hexbuffer(""generate_key_derivation: [[IN]]  sec       "", sec_x.data, 32);
        this->controle_device->generate_key_derivation(pub_x, sec_x, derivation_x);
        hw::ledger::log_hexbuffer(""generate_key_derivation: [[OUT]] derivation"", derivation_x.data, 32);
        #endif

      if ((this->mode == TRANSACTION_PARSE)  && has_view_key) {
        //A derivation is resquested in PASRE mode and we have the view key,
        //so do that wihtout the device and return the derivation unencrypted.
        MDEBUG( ""generate_key_derivation  : PARSE mode with known viewkey"");     
        //Note derivation in PARSE mode can only happen with viewkey, so assert it!
        assert(is_fake_view_key(sec));
        r = crypto::generate_key_derivation(pub, this->viewkey, derivation);
      } else {

        int offset = set_command_header_noopt(INS_GEN_KEY_DERIVATION);
        //pub
        memmove(this->buffer_send+offset, pub.data, 32);
        offset += 32;
         //sec
        memmove(this->buffer_send+offset, sec.data, 32);
        offset += 32;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        //derivattion data
        memmove(derivation.data, &this->buffer_recv[0], 32);
        r = true;
      }
      #ifdef DEBUG_HWDEVICE
      crypto::key_derivation derivation_clear ;
        if ((this->mode == TRANSACTION_PARSE)  && has_view_key) {
          derivation_clear  = derivation;
        }else {
          derivation_clear  = hw::ledger::decrypt(derivation);
        }
      hw::ledger::check32(""generate_key_derivation"", ""derivation"", derivation_x.data, derivation_clear.data);
      #endif

      return r;
    }

    bool device_ledger::conceal_derivation(crypto::key_derivation &derivation, const crypto::public_key &tx_pub_key, const std::vector<crypto::public_key> &additional_tx_pub_keys, const crypto::key_derivation &main_derivation, const std::vector<crypto::key_derivation> &additional_derivations) {
      const crypto::public_key *pkey=NULL;
      if (derivation == main_derivation) {        
        pkey = &tx_pub_key;
        MDEBUG(""conceal derivation with main tx pub key"");
      } else {
        for(size_t n=0; n < additional_derivations.size();++n) {
          if(derivation == additional_derivations[n]) {
            pkey = &additional_tx_pub_keys[n];
            MDEBUG(""conceal derivation with additionnal tx pub key"");
            break;
          }
        }
      }
      ASSERT_X(pkey, ""Mismatched derivation on scan info"");
      return this->generate_key_derivation(*pkey,  crypto::null_skey, derivation);
    } 

    bool device_ledger::derivation_to_scalar(const crypto::key_derivation &derivation, const size_t output_index, crypto::ec_scalar &res) {
        AUTO_LOCK_CMD();

        #ifdef DEBUG_HWDEVICE
        const crypto::key_derivation derivation_x = hw::ledger::decrypt(derivation);
        const size_t output_index_x               = output_index;
        crypto::ec_scalar res_x;
        hw::ledger::log_hexbuffer(""derivation_to_scalar: [[IN]]  derivation    "", derivation_x.data, 32);
        hw::ledger::log_message  (""derivation_to_scalar: [[IN]]  output_index  "", std::to_string(output_index_x));
        this->controle_device->derivation_to_scalar(derivation_x, output_index_x, res_x);
        hw::ledger::log_hexbuffer(""derivation_to_scalar: [[OUT]] res          "", res_x.data, 32);
        #endif

        int offset = set_command_header_noopt(INS_DERIVATION_TO_SCALAR);
        //derivattion
        memmove(this->buffer_send+offset, derivation.data, 32);
        offset += 32;
        //index
        this->buffer_send[offset+0] = output_index>>24;
        this->buffer_send[offset+1] = output_index>>16;
        this->buffer_send[offset+2] = output_index>>8;
        this->buffer_send[offset+3] = output_index>>0;
        offset += 4;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        //derivattion data
        memmove(res.data, &this->buffer_recv[0], 32);

        #ifdef DEBUG_HWDEVICE
        crypto::ec_scalar res_clear  = hw::ledger::decrypt(res);
        hw::ledger::check32(""derivation_to_scalar"", ""res"", res_x.data, res_clear.data);
        #endif

        return true;
    }

    bool device_ledger::derive_secret_key(const crypto::key_derivation &derivation, const std::size_t output_index, const crypto::secret_key &sec, crypto::secret_key &derived_sec) {
        AUTO_LOCK_CMD();

        #ifdef DEBUG_HWDEVICE
        const crypto::key_derivation derivation_x   = hw::ledger::decrypt(derivation);
        const std::size_t            output_index_x = output_index;
        const crypto::secret_key     sec_x          = hw::ledger::decrypt(sec);
        crypto::secret_key           derived_sec_x;
        hw::ledger::log_hexbuffer(""derive_secret_key: [[IN]]  derivation "", derivation_x.data, 32);
        hw::ledger::log_message  (""derive_secret_key: [[IN]]  index      "", std::to_string(output_index_x));
        hw::ledger::log_hexbuffer(""derive_secret_key: [[IN]]  sec        "", sec_x.data, 32);
        this->controle_device->derive_secret_key(derivation_x, output_index_x, sec_x, derived_sec_x);
        hw::ledger::log_hexbuffer(""derive_secret_key: [[OUT]] derived_sec"", derived_sec_x.data, 32);
        #endif

        int offset = set_command_header_noopt(INS_DERIVE_SECRET_KEY);
        //derivation
        memmove(this->buffer_send+offset, derivation.data, 32);
        offset += 32;
        //index
        this->buffer_send[offset+0] = output_index>>24;
        this->buffer_send[offset+1] = output_index>>16;
        this->buffer_send[offset+2] = output_index>>8;
        this->buffer_send[offset+3] = output_index>>0;
        offset += 4;
        //sec
        memmove(this->buffer_send+offset, sec.data, 32);
        offset += 32;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        //pub key
        memmove(derived_sec.data, &this->buffer_recv[0], 32);

        #ifdef DEBUG_HWDEVICE
        crypto::secret_key derived_sec_clear = hw::ledger::decrypt(derived_sec);
        hw::ledger::check32(""derive_secret_key"", ""derived_sec"", derived_sec_x.data, derived_sec_clear.data);
        #endif

        return true;
    }

    bool device_ledger::derive_public_key(const crypto::key_derivation &derivation, const std::size_t output_index, const crypto::public_key &pub, crypto::public_key &derived_pub){
        AUTO_LOCK_CMD();
      
        #ifdef DEBUG_HWDEVICE
        const crypto::key_derivation derivation_x   = hw::ledger::decrypt(derivation);
        const std::size_t            output_index_x = output_index;
        const crypto::public_key     pub_x        = pub;
        crypto::public_key           derived_pub_x;
        hw::ledger::log_hexbuffer(""derive_public_key: [[IN]]  derivation  "", derivation_x.data, 32);
        hw::ledger::log_message  (""derive_public_key: [[IN]]  output_index"", std::to_string(output_index_x));
        hw::ledger::log_hexbuffer(""derive_public_key: [[IN]]  pub         "", pub_x.data, 32);
        this->controle_device->derive_public_key(derivation_x, output_index_x, pub_x, derived_pub_x);
        hw::ledger::log_hexbuffer(""derive_public_key: [[OUT]] derived_pub "", derived_pub_x.data, 32);
        #endif

        int offset = set_command_header_noopt(INS_DERIVE_PUBLIC_KEY);
        //derivation
        memmove(this->buffer_send+offset, derivation.data, 32);
        offset += 32;
        //index
        this->buffer_send[offset+0] = output_index>>24;
        this->buffer_send[offset+1] = output_index>>16;
        this->buffer_send[offset+2] = output_index>>8;
        this->buffer_send[offset+3] = output_index>>0;
        offset += 4;
        //pub
        memmove(this->buffer_send+offset, pub.data, 32);
        offset += 32;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        //pub key
        memmove(derived_pub.data, &this->buffer_recv[0], 32);

        #ifdef DEBUG_HWDEVICE
        hw::ledger::check32(""derive_public_key"", ""derived_pub"", derived_pub_x.data, derived_pub.data);
        #endif

        return true;
    }

    bool device_ledger::secret_key_to_public_key(const crypto::secret_key &sec, crypto::public_key &pub) {
        AUTO_LOCK_CMD();

        #ifdef DEBUG_HWDEVICE
        const crypto::secret_key sec_x = hw::ledger::decrypt(sec);
        crypto::public_key       pub_x;
        hw::ledger::log_hexbuffer(""secret_key_to_public_key: [[IN]] sec "", sec_x.data, 32);
        bool rc = this->controle_device->secret_key_to_public_key(sec_x, pub_x);
        hw::ledger::log_hexbuffer(""secret_key_to_public_key: [[OUT]] pub"", pub_x.data, 32);
        if (!rc){
          hw::ledger::log_message(""secret_key_to_public_key"", ""secret_key rejected"");
        }
        #endif

        int offset = set_command_header_noopt(INS_SECRET_KEY_TO_PUBLIC_KEY);
        //sec key
        memmove(this->buffer_send+offset, sec.data, 32);
        offset += 32;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        //pub key
        memmove(pub.data, &this->buffer_recv[0], 32);

        #ifdef DEBUG_HWDEVICE
        hw::ledger::check32(""secret_key_to_public_key"", ""pub"", pub_x.data, pub.data);
        #endif

        return true;
    }

    bool device_ledger::generate_key_image(const crypto::public_key &pub, const crypto::secret_key &sec, crypto::key_image &image){
        AUTO_LOCK_CMD();

        #ifdef DEBUG_HWDEVICE
        const crypto::public_key pub_x = pub;
        const crypto::secret_key sec_x = hw::ledger::decrypt(sec);
        crypto::key_image        image_x;
        hw::ledger::log_hexbuffer(""generate_key_image: [[IN]]  pub "", pub_x.data, 32);
        hw::ledger::log_hexbuffer(""generate_key_image: [[IN]]  sec "", sec_x.data, 32);
        this->controle_device->generate_key_image(pub_x, sec_x, image_x);
        hw::ledger::log_hexbuffer(""generate_key_image: [[OUT]] image "", image_x.data, 32);
        #endif

        int offset = set_command_header_noopt(INS_GEN_KEY_IMAGE);
        //pub
        memmove(this->buffer_send+offset, pub.data, 32);
        offset += 32;
        //sec
        memmove(this->buffer_send+offset, sec.data, 32);
        offset += 32;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        //pub key
        memmove(image.data, &this->buffer_recv[0], 32);

        #ifdef DEBUG_HWDEVICE
        hw::ledger::check32(""generate_key_image"", ""image"", image_x.data, image.data);
        #endif

        return true;
    }

    /* ======================================================================= */
    /*                               TRANSACTION                               */
    /* ======================================================================= */

    bool device_ledger::open_tx(crypto::secret_key &tx_key) {
        AUTO_LOCK_CMD();

        key_map.clear();
        int offset = set_command_header_noopt(INS_OPEN_TX, 0x01);

        //account
        this->buffer_send[offset+0] = 0x00;
        this->buffer_send[offset+1] = 0x00;
        this->buffer_send[offset+2] = 0x00;
        this->buffer_send[offset+3] = 0x00;
        offset += 4;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        memmove(tx_key.data, &this->buffer_recv[32], 32);
  
        return true;
    }

    bool device_ledger::encrypt_payment_id(crypto::hash8 &payment_id, const crypto::public_key &public_key, const crypto::secret_key &secret_key) {
        AUTO_LOCK_CMD();

        #ifdef DEBUG_HWDEVICE
        const crypto::public_key public_key_x = public_key;
        const crypto::secret_key secret_key_x = hw::ledger::decrypt(secret_key);
        crypto::hash8 payment_id_x = payment_id;
        this->controle_device->encrypt_payment_id(payment_id_x, public_key_x, secret_key_x);
        #endif

        int offset = set_command_header_noopt(INS_STEALTH);
        //pub
        memmove(&this->buffer_send[offset], public_key.data, 32);
        offset += 32;
        //sec
        memmove(&this->buffer_send[offset], secret_key.data, 32);
        offset += 32;
        //id
        memmove(&this->buffer_send[offset], payment_id.data, 8);
        offset += 8;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();
        memmove(payment_id.data, &this->buffer_recv[0], 8);

        #ifdef DEBUG_HWDEVICE
        hw::ledger::check8(""stealth"", ""payment_id"", payment_id_x.data, payment_id.data);
        #endif

        return true;
    }

    bool device_ledger::add_output_key_mapping(const crypto::public_key &Aout, const crypto::public_key &Bout, const bool is_subaddress, const size_t real_output_index,
                                               const rct::key &amount_key,  const crypto::public_key &out_eph_public_key)  {
        AUTO_LOCK_CMD();
        key_map.add(ABPkeys(rct::pk2rct(Aout),rct::pk2rct(Bout), is_subaddress, real_output_index, rct::pk2rct(out_eph_public_key), amount_key));
        return true;
    }

    bool  device_ledger::ecdhEncode(rct::ecdhTuple & unmasked, const rct::key & AKout) {
        AUTO_LOCK_CMD();

        #ifdef DEBUG_HWDEVICE
        const rct::key AKout_x =   hw::ledger::decrypt(AKout);
        rct::ecdhTuple unmasked_x = unmasked;
        this->controle_device->ecdhEncode(unmasked_x, AKout_x);
        #endif

        int offset = set_command_header_noopt(INS_BLIND);
        // AKout
        memmove(this->buffer_send+offset, AKout.bytes, 32);
        offset += 32;
        //mask k
        memmove(this->buffer_send+offset, unmasked.mask.bytes, 32);
        offset += 32;
        //value v
        memmove(this->buffer_send+offset, unmasked.amount.bytes, 32);
        offset += 32;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        memmove(unmasked.amount.bytes, &this->buffer_recv[0],  32);
        memmove(unmasked.mask.bytes,  &this->buffer_recv[32], 32);

        #ifdef DEBUG_HWDEVICE
        hw::ledger::check32(""ecdhEncode"", ""amount"", (char*)unmasked_x.amount.bytes, (char*)unmasked.amount.bytes);
        hw::ledger::check32(""ecdhEncode"", ""mask"", (char*)unmasked_x.mask.bytes, (char*)unmasked.mask.bytes);

        hw::ledger::log_hexbuffer(""Blind AKV input"", (char*)&this->buffer_recv[64], 3*32);
        #endif

        return true;
    }

    bool  device_ledger::ecdhDecode(rct::ecdhTuple & masked, const rct::key & AKout) {
        AUTO_LOCK_CMD();

        #ifdef DEBUG_HWDEVICE
        const rct::key AKout_x =   hw::ledger::decrypt(AKout);
        rct::ecdhTuple masked_x = masked;
        this->controle_device->ecdhDecode(masked_x, AKout_x);
        #endif

        int offset = set_command_header_noopt(INS_UNBLIND);

        // AKout
        memmove(this->buffer_send+offset, AKout.bytes, 32);
        offset += 32;
        //mask k
        memmove(this->buffer_send+offset, masked.mask.bytes, 32);
        offset += 32;
        //value v
        memmove(this->buffer_send+offset, masked.amount.bytes, 32);
        offset += 32;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        memmove(masked.amount.bytes, &this->buffer_recv[0],  32);
        memmove(masked.mask.bytes,  &this->buffer_recv[32], 32);

        #ifdef DEBUG_HWDEVICE
        hw::ledger::check32(""ecdhDecode"", ""amount"", (char*)masked_x.amount.bytes, (char*)masked.amount.bytes);
        hw::ledger::check32(""ecdhDecode"", ""mask"", (char*)masked_x.mask.bytes,(char*) masked.mask.bytes);
        #endif

        return true;
    }

    bool device_ledger::mlsag_prehash(const std::string &blob, size_t inputs_size, size_t outputs_size,
                                     const rct::keyV &hashes, const rct::ctkeyV &outPk,
                                     rct::key &prehash) {
        AUTO_LOCK_CMD();
        unsigned int  data_offset, C_offset, kv_offset, i;
        const char *data;

        #ifdef DEBUG_HWDEVICE
        const std::string blob_x  = blob;
        size_t inputs_size_x      = inputs_size;
        size_t outputs_size_x     = outputs_size;
        const rct::keyV hashes_x  = hashes;
        const rct::ctkeyV outPk_x = outPk;
        rct::key prehash_x;
        this->controle_device->mlsag_prehash(blob_x, inputs_size_x, outputs_size_x, hashes_x, outPk_x, prehash_x);
        if (inputs_size) {
          log_message(""mlsag_prehash"", (std::string(""inputs_size not null: "") +  std::to_string(inputs_size)).c_str());
        }
        this->key_map.log();
        #endif

        data = blob.data();

        // ======  u8 type, varint txnfee ======
        int offset = set_command_header(INS_VALIDATE, 0x01, 0x01);
        //options
        this->buffer_send[offset] = (inputs_size == 0)?0x00:0x80;
        offset += 1;

        //type
        uint8_t type = data[0];
        this->buffer_send[offset] = data[0];
        offset += 1;

        //txnfee
        data_offset = 1;
        while (data[data_offset]&0x80) {
          this->buffer_send[offset] = data[data_offset];
          offset += 1;
          data_offset += 1;
        }
        this->buffer_send[offset] = data[data_offset];
        offset += 1;
        data_offset += 1;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        //pseudoOuts
        if ((type == rct::RCTTypeSimple) || (type == rct::RCTTypeSimpleBulletproof)) {
          for ( i = 0; i < inputs_size; i++) {
            offset = set_command_header(INS_VALIDATE, 0x01, i+2);
            //options
            this->buffer_send[offset] = (i==inputs_size-1)? 0x00:0x80;
            offset += 1;
            //pseudoOut
            memmove(this->buffer_send+offset, data+data_offset,32);
            offset += 32;
            data_offset += 32;

            this->buffer_send[4] = offset-5;
            this->length_send = offset;
            this->exchange();
          }
        }

        // ======  Aout, Bout, AKout, C, v, k ======
        kv_offset = data_offset;
        C_offset = kv_offset+ (32*2)*outputs_size;
        for ( i = 0; i < outputs_size; i++) {
          ABPkeys outKeys;
          bool found;

          found = this->key_map.find(outPk[i].dest, outKeys);
          if (!found) {
            log_hexbuffer(""Pout not found"", (char*)outPk[i].dest.bytes, 32);
            CHECK_AND_ASSERT_THROW_MES(found, ""Pout not found"");
          }
          offset = set_command_header(INS_VALIDATE, 0x02, i+1);
          //options
          this->buffer_send[offset] = (i==outputs_size-1)? 0x00:0x80 ;
          offset += 1;
          if (found) {
            //is_subaddress
            this->buffer_send[offset] = outKeys.is_subaddress;
            offset++;
            //Aout
            memmove(this->buffer_send+offset, outKeys.Aout.bytes, 32);
            offset+=32;
            //Bout
            memmove(this->buffer_send+offset, outKeys.Bout.bytes, 32);
            offset+=32;
            //AKout
            memmove(this->buffer_send+offset, outKeys.AKout.bytes, 32);
            offset+=32;
          } else {
            // dummy: is_subaddress Aout Bout AKout
            offset += 1+32*3;
          }
          //C
          memmove(this->buffer_send+offset, data+C_offset,32);
          offset += 32;
          C_offset += 32;
          //k
          memmove(this->buffer_send+offset, data+kv_offset,32);
          offset += 32;
          //v
          kv_offset += 32;
          memmove(this->buffer_send+offset, data+kv_offset,32);
          offset += 32;
          kv_offset += 32;

          this->buffer_send[4] = offset-5;
          this->length_send = offset;
          this->exchange();
          #ifdef DEBUG_HWDEVICE
          hw::ledger::log_hexbuffer(""Prehash AKV input"", (char*)&this->buffer_recv[64], 3*32);
          #endif
        }

        // ======   C[], message, proof======
        C_offset = kv_offset;
        for (i = 0; i < outputs_size; i++) {
          offset = set_command_header(INS_VALIDATE, 0x03, i+1);
          //options
          this->buffer_send[offset] = 0x80 ;
          offset += 1;
          //C
          memmove(this->buffer_send+offset, data+C_offset,32);
          offset += 32;
          C_offset += 32;

          this->buffer_send[4] = offset-5;
          this->length_send = offset;
          this->exchange();

        }

        offset = set_command_header_noopt(INS_VALIDATE, 0x03, i+1);
        //message
        memmove(this->buffer_send+offset, hashes[0].bytes,32);
        offset += 32;
        //proof
        memmove(this->buffer_send+offset,  hashes[2].bytes,32);
        offset += 32;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        memmove(prehash.bytes, this->buffer_recv,  32);

        #ifdef DEBUG_HWDEVICE
        hw::ledger::check32(""mlsag_prehash"", ""prehash"", (char*)prehash_x.bytes, (char*)prehash.bytes);
        #endif

        return true;
    }


    bool device_ledger::mlsag_prepare(const rct::key &H, const rct::key &xx,
                                     rct::key &a, rct::key &aG, rct::key &aHP, rct::key &II) {
        AUTO_LOCK_CMD();
        unsigned char options;

        #ifdef DEBUG_HWDEVICE
        const rct::key H_x = H;
        const rct::key xx_x = hw::ledger::decrypt(xx);
        rct::key a_x;
        rct::key aG_x;
        rct::key aHP_x;
        rct::key II_x;
        #endif

        int offset = set_command_header_noopt(INS_MLSAG, 0x01);
        //value H
        memmove(this->buffer_send+offset, H.bytes, 32);
        offset += 32;
        //mask xin
        memmove(this->buffer_send+offset, xx.bytes, 32);
        offset += 32;

        this->buffer_send[4] = offset-5;
        this->length_send = offset;
        this->exchange();

        memmove(a.bytes,   &this->buffer_recv[32*0], 32);
        memmove(aG.bytes,  &this->buffer_recv[32*1], 32);
        memmove(aHP.bytes, &this->buffer_recv[32*2], 32);
        memmove(II.bytes,  &this->buffer_recv[32*3], 32);

        #ifdef DEBUG_HWDEVICE
        a_x = hw::ledger::decrypt(a);

        rct::scalarmultBase(aG_x, a_x);
        rct::scalarmultKey(aHP_x, H_x, a_x);
        rct::scalarmultKey(II_x, H_x, xx_x);
        hw::ledger::check32(""mlsag_prepare"", ""AG"", (char*)aG_x.bytes, (char*)aG.bytes);
        hw::ledger::check32(""mlsag_prepare"", ""aHP"", (char*)aHP_x.bytes, (char*)aHP.bytes);
        hw::ledger::check32(""mlsag_prepare"", ""II"", (char*)II_x.bytes, (char*)II.bytes);
        #endif

        return true;
    }

    bool device_ledger::mlsag_prepare(rct::key &a, rct::key &aG) {
        AUTO_LOCK_CMD();
        unsigned char options;

        #ifdef DEBUG_HWDEVICE
        rct::key a_x;
        rct::key aG_x;
        #endif

        send_simple(INS_MLSAG, 0x01);

        memmove(a.bytes,   &this->buffer_recv[32*0], 32);
        memmove(aG.bytes,  &this->buffer_recv[32*1], 32);

        #ifdef DEBUG_HWDEVICE
        a_x = hw::ledger::decrypt(a);
        rct::scalarmultBase(aG_x, a_x);
        hw::ledger::check32(""mlsag_prepare"", ""AG"", (char*)aG_x.bytes, (char*)aG.bytes);
        #endif

        return true;
    }

    bool device_ledger::mlsag_hash(const rct::keyV &long_message, rct::key &c) {
        AUTO_LOCK_CMD();
        unsigned char options;
        size_t cnt;

        #ifdef DEBUG_HWDEVICE
        const rct::keyV long_message_x = long_message;
        rct::key c_x;
        this->controle_device->mlsag_hash(long_message_x, c_x);
        #endif

        cnt = long_message.size();
        for (size_t i = 0; i<cnt; i++) {
          int offset = set_command_header(INS_MLSAG, 0x02, i+1);
          //options
          this->buffer_send[offset] =
              (i==(cnt-1))?0x00:0x80;  //last
          offset += 1;
          //msg part
          memmove(this->buffer_send+offset, long_message[i].bytes, 32);
          offset += 32;

          this->buffer_send[4] = offset-5;
          this->length_send = offset;
          this->exchange();
        }

        memmove(c.bytes, &this->buffer_recv[0], 32);

        #ifdef DEBUG_HWDEVICE
        hw::ledger::check32(""mlsag_hash"", ""c"", (char*)c_x.bytes, (char*)c.bytes);
        #endif

        return true;
    }

    bool device_ledger::mlsag_sign(const rct::key &c, const rct::keyV &xx, const rct::keyV &alpha, const size_t rows, const size_t dsRows, rct::keyV &ss) {
        AUTO_LOCK_CMD();

        CHECK_AND_ASSERT_THROW_MES(dsRows<=rows, ""dsRows greater than rows"");
        CHECK_AND_ASSERT_THROW_MES(xx.size() == rows, ""xx size does not match rows"");
        CHECK_AND_ASSERT_THROW_MES(alpha.size() == rows, ""alpha size does not match rows"");
        CHECK_AND_ASSERT_THROW_MES(ss.size() == rows, ""ss size does not match rows"");

        #ifdef DEBUG_HWDEVICE
        const rct::key c_x      = c;
        const rct::keyV xx_x    = hw::ledger::decrypt(xx);
        const rct::keyV alpha_x = hw::ledger::decrypt(alpha);
        const int rows_x        = rows;
        const int dsRows_x      = dsRows;
        rct::keyV ss_x(ss.size());
        this->controle_device->mlsag_sign(c_x, xx_x, alpha_x, rows_x, dsRows_x, ss_x);
        #endif

        for (size_t j = 0; j < dsRows; j++) {
          int offset = set_command_header(INS_MLSAG, 0x03, j+1);
          //options
          this->buffer_send[offset] = 0x00;
          if (j==(dsRows-1)) {
            this->buffer_send[offset]  |= 0x80;  //last
          }
          offset += 1;
          //xx
          memmove(this->buffer_send+offset, xx[j].bytes, 32);
          offset += 32;
          //alpa
          memmove(this->buffer_send+offset, alpha[j].bytes, 32);
          offset += 32;

          this->buffer_send[4] = offset-5;
          this->length_send = offset;
          this->exchange();

          //ss
          memmove(ss[j].bytes, &this->buffer_recv[0], 32);
        }

        for (size_t j = dsRows; j < rows; j++) {
          sc_mulsub(ss[j].bytes, c.bytes, xx[j].bytes, alpha[j].bytes);
        }

        #ifdef DEBUG_HWDEVICE
        for (size_t j = 0; j < rows; j++) {
           hw::ledger::check32(""mlsag_sign"", ""ss[""+std::to_string(j)+""]"", (char*)ss_x[j].bytes, (char*)ss[j].bytes);
        }
        #endif

        return true;
    }

    bool device_ledger::close_tx() {
        AUTO_LOCK_CMD();
        send_simple(INS_CLOSE_TX);
        return true;
    }

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

    static device_ledger *legder_device = NULL;
    void register_all(std::map<std::string, std::unique_ptr<device>> &registry) {
      if (!legder_device) {
        legder_device = new device_ledger();
        legder_device->set_name(""Ledger"");
      }
      registry.insert(std::make_pair(""Ledger"", std::unique_ptr<device>(legder_device)));
    }
  
  #else //WITH_DEVICE_LEDGER
  
    void register_all(std::map<std::string, std::unique_ptr<device>> &registry) {
    }

  #endif //WITH_DEVICE_LEDGER

  }
}

",16136,True,3257.033876055521,median
"== Raspicam commands

`raspistill`, `raspivid` and `raspiyuv` are command line tools for using the camera module.

=== Enabling the Camera

Before using any of the _Raspicam_ applications, the camera must be enabled.

==== On the desktop

Select `Preferences` and `Raspberry Pi Configuration` from the desktop menu: a window will appear. Select the `Interfaces` tab, then click on the `enable camera` option. Click `OK`. You will need to reboot for the changes to take effect.

==== With the command line

Open the `raspi-config` tool from the terminal:

[,bash]
----
sudo raspi-config
----

Select `Interfacing Options` then `Camera` and press `Enter`. Choose `Yes` then `Ok`. Go to `Finish` and you'll be prompted to reboot.

To test that the system is installed and working, try the following command:

[,bash]
----
raspistill -v -o test.jpg
----

The display should show a five-second preview from the camera and then take a picture, saved to the file `test.jpg`, whilst displaying various informational messages.

=== `raspistill`

`raspistill` is the command line tool for capturing still photographs with a Raspberry Pi camera module.

==== Basic usage of raspistill

With a camera module xref:camera.adoc#camera-modules[connected and enabled], enter the following command in the terminal to take a picture:

[,bash]
----
raspistill -o cam.jpg
----

image::images/cam.jpg[Upside-down photo]

In this example the camera has been positioned upside-down. If the camera is placed in this position, the image must be flipped to appear the right way up.

==== Vertical flip and horizontal flip

With the camera placed upside-down, the image must be rotated 180° to be displayed correctly. The way to correct for this is to apply both a vertical and a horizontal flip by passing in the `-vf` and `-hf` flags:

[,bash]
----
raspistill -vf -hf -o cam2.jpg
----

image::images/cam2.jpg[Vertical and horizontal flipped photo]

Now the photo has been captured correctly.

==== Resolution

The camera module takes pictures at a resolution of `2592 x 1944` which is 5,038,848 pixels or 5 megapixels.

==== File size

A photo taken with the camera module will be around 2.4MB. This is about 425 photos per GB.

Taking 1 photo per minute would take up 1GB in about 7 hours. This is a rate of about 144MB per hour or 3.3GB per day.

==== Bash script

You can create a Bash script which takes a picture with the camera. To create a script, open up your editor of choice and write the following example code:

[,bash]
----
#!/bin/bash

DATE=$(date +""%Y-%m-%d_%H%M"")

raspistill -vf -hf -o /home/pi/camera/$DATE.jpg
----

This script will take a picture and name the file with a timestamp.

You'll also need to make sure the path exists by creating the `camera` folder:

[,bash]
----
mkdir camera
----

Say we saved it as `camera.sh`, we would first make the file executable:

[,bash]
----
chmod +x camera.sh
----

Then run with:

[,bash]
----
./camera.sh
----

==== More options

For a full list of possible options, run `raspistill` with no arguments. To scroll, redirect stderr to stdout and pipe the output to `less`:

[,bash]
----
raspistill 2>&1 | less
----

Use the arrow keys to scroll and type `q` to exit.

=== `raspivid`

`raspivid` is the command line tool for capturing video with a Raspberry Pi camera module.

==== Basic usage of raspivid

With a camera module xref:camera.adoc#camera-modules[connected and enabled], record a video using the following command:

[,bash]
----
raspivid -o vid.h264
----

Remember to use `-hf` and `-vf` to flip the image if required, like with xref:camera.adoc#raspistill[raspistill]

This will save a 5 second video file to the path given here as `vid.h264` (default length of time).

==== Specify length of video

To specify the length of the video taken, pass in the `-t` flag with a number of milliseconds. For example:

[,bash]
----
raspivid -o video.h264 -t 10000
----

This will record 10 seconds of video.

==== More options

For a full list of possible options, run `raspivid` with no arguments, or pipe this command through `less` and scroll through:

[,bash]
----
raspivid 2>&1 | less
----

Use the arrow keys to scroll and type `q` to exit.

==== MP4 Video Format

The Pi captures video as a raw H264 video stream. Many media players will refuse to play it, or play it at an incorrect speed, unless it is ""wrapped"" in a suitable container format like MP4. The easiest way to obtain an MP4 file from the raspivid command is using MP4Box.

Install MP4Box with this command:

[,bash]
----
sudo apt install -y gpac
----

Capture your raw video with raspivid and wrap it in an MP4 container like this:

[,bash]
----
# Capture 30 seconds of raw video at 640x480 and 150kB/s bit rate into a pivideo.h264 file:
raspivid -t 30000 -w 640 -h 480 -fps 25 -b 1200000 -p 0,0,640,480 -o pivideo.h264
# Wrap the raw video with an MP4 container:
MP4Box -add pivideo.h264 pivideo.mp4
# Remove the source raw file, leaving the remaining pivideo.mp4 file to play
rm pivideo.h264
----

Alternatively, wrap MP4 around your existing raspivid output, like this:

[,bash]
----
MP4Box -add video.h264 video.mp4
----

=== `raspiyuv`

`raspiyuv` has the same set of features as `raspistill` but instead of outputting standard image files such as ``.jpg``s, it generates YUV420 or RGB888 image files from the output of the camera ISP.

In most cases using `raspistill` is the best option for standard image capture, but using YUV can be of benefit in certain circumstances. For example if you just need a uncompressed black and white image for computer vision applications, you can simply use the Y channel of a YUV capture.

There are some specific points about the YUV420 files that are required in order to use them correctly. Line stride (or pitch) is a multiple of 32, and each plane of YUV is a multiple of 16 in height. This can mean there may be extra pixels at the end of lines, or gaps between planes, depending on the resolution of the captured image. These gaps are unused.

=== Troubleshooting

If the Camera Module isn't working correctly, there are number of things to try:

* Is the ribbon cable attached to the Camera Serial Interface (CSI), not the Display Serial Interface (DSI)? The ribbon connector will fit into either port. The Camera port is located near the HDMI connector.
* Are the ribbon connectors all firmly seated, and are they the right way round? They must be straight in their sockets.
* Is the Camera Module connector, between the smaller black Camera Module itself and the PCB, firmly attached? Sometimes this connection can come loose during transit or when putting the Camera Module in a case. Using a fingernail, flip up the connector on the PCB, then reconnect it with gentle pressure. It engages with a very slight click. Don't force it; if it doesn't engage, it's probably slightly misaligned.
* Have `sudo apt update` and `sudo apt full-upgrade` been run?
* Has `raspi-config` been run and the Camera Module enabled?
* Is your power supply sufficient? The Camera Module adds about 200-250mA to the power requirements of your Raspberry Pi.

If things are still not working, try the following:

* `Error : raspistill/raspivid command not found`. This probably means your update/upgrade failed in some way. Try it again.
* `Error : ENOMEM`. The Camera Module is not starting up. Check all connections again.
* `Error : ENOSPC`. The Camera Module is probably running out of GPU memory. Check `config.txt` in the /boot/ folder. The `gpu_mem` option should be at least 128. Alternatively, use the Memory Split option in the Advanced section of `raspi-config` to set this.
* If you've checked all the above issues and the Camera Module is still not working, try posting on our forums for more help.

=== Command Line Options

==== Preview window

----
	--preview,	-p		Preview window settings <'x,y,w,h'>
----

Allows the user to define the size of the preview window and its location on the screen. Note this will be superimposed over the top of any other windows/graphics.

----
	--fullscreen,	-f		Fullscreen preview mode
----

Forces the preview window to use the whole screen. Note that the aspect ratio of the incoming image will be retained, so there may be bars on some edges.

----
	--nopreview,	-n		Do not display a preview window
----

Disables the preview window completely. Note that even though the preview is disabled, the camera will still be producing frames, so will be using power.

----
	--opacity,	-op		Set preview window opacity
----

Sets the opacity of the preview windows. 0 = invisible, 255 = fully opaque.

==== Camera control options

----
	--sharpness,	-sh		Set image sharpness (-100 - 100)
----

Sets the sharpness of the image. 0 is the default.

----
	--contrast,	-co		Set image contrast (-100 - 100)
----

Sets the contrast of the image. 0 is the default.

----
	--brightness,	-br		Set image brightness (0 - 100)
----

Sets the brightness of the image. 50 is the default. 0 is black, 100 is white.

----
	--saturation,	-sa		Set image saturation (-100 - 100)
----

Sets the colour saturation of the image. 0 is the default.

----
	--ISO,	-ISO		Set capture ISO (100 - 800)
----

Sets the ISO to be used for captures.

----
	--vstab,	-vs		Turn on video stabilisation
----

In video mode only, turns on video stabilisation.

----
	--ev,	-ev		Set EV compensation (-10 - 10)
----

Sets the EV compensation of the image. Default is 0.

----
	--exposure,	-ex		Set exposure mode
----

Possible options are:

* auto: use automatic exposure mode
* night: select setting for night shooting
* nightpreview:
* backlight: select setting for backlit subject
* spotlight:
* sports: select setting for sports (fast shutter etc.)
* snow: select setting optimised for snowy scenery
* beach: select setting optimised for beach
* verylong: select setting for long exposures
* fixedfps: constrain fps to a fixed value
* antishake: antishake mode
* fireworks: select setting optimised for fireworks

Note that not all of these settings may be implemented, depending on camera tuning.

----
	--flicker, -fli		Set flicker avoidance mode
----

Set a mode to compensate for lights flickering at the mains frequency, which can be seen as a dark horizontal band across an image. Flicker avoidance locks the exposure time to a multiple of the mains flicker frequency (8.33ms for 60Hz, or 10ms for 50Hz). This means that images can be noisier as the control algorithm has to increase the gain instead of exposure time should it wish for an intermediate exposure value. `auto` can be confused by external factors, therefore it is preferable to leave this setting off unless actually required.

Possible options are:

* off: turn off flicker avoidance
* auto: automatically detect mains frequency
* 50hz: set avoidance at 50Hz
* 60hz: set avoidance at 60Hz

----
	--awb,	-awb		Set Automatic White Balance (AWB) mode
----

Modes for which colour temperature ranges (K) are available have these settings in brackets.

* off: turn off white balance calculation
* auto: automatic mode (default)
* sun: sunny mode (between 5000K and 6500K)
* cloud: cloudy mode (between 6500K and 12000K)
* shade: shade mode
* tungsten: tungsten lighting mode (between 2500K and 3500K)
* fluorescent: fluorescent lighting mode (between 2500K and 4500K)
* incandescent: incandescent lighting mode
* flash: flash mode
* horizon: horizon mode
* greyworld: Use this on the NoIR camera to fix incorrect AWB results due to the lack of the IR filter.

Note that not all of these settings may be implemented, depending on camera type.

----
	--imxfx,	-ifx		Set image effect
----

Set an effect to be applied to the image:

* none: no effect (default)
* negative: invert the image colours
* solarise: solarise the image
* posterise: posterise the image
* whiteboard: whiteboard effect
* blackboard: blackboard effect
* sketch: sketch effect
* denoise: denoise the image
* emboss: emboss the image
* oilpaint: oil paint effect
* hatch: hatch sketch effect
* gpen: graphite sketch effect
* pastel: pastel effect
* watercolour: watercolour effect
* film: film grain effect
* blur: blur the image
* saturation: colour saturate the image
* colourswap: not fully implemented
* washedout: not fully implemented
* colourpoint: not fully implemented
* colourbalance: not fully implemented
* cartoon: not fully implemented

Note that not all of these settings may be available in all circumstances.

----
	--colfx,	-cfx		Set colour effect <U:V>
----

The supplied U and V parameters (range 0 - 255) are applied to the U and Y channels of the image. For example, --colfx 128:128 should result in a monochrome image.

----
	--metering,	-mm		Set metering mode
----

Specify the metering mode used for the preview and capture:

* average: average the whole frame for metering
* spot: spot metering
* backlit: assume a backlit image
* matrix: matrix metering

----
	--rotation,	-rot		Set image rotation (0 - 359)
----

Sets the rotation of the image in the viewfinder and resulting image. This can take any value from 0 upwards, but due to hardware constraints only 0, 90, 180, and 270 degree rotations are supported.

----
	--hflip,	-hf		Set horizontal flip
----

Flips the preview and saved image horizontally.

----
	--vflip,	-vf		Set vertical flip
----

Flips the preview and saved image vertically.

----
	--roi,	-roi		Set sensor region of interest
----

Allows the specification of the area of the sensor to be used as the source for the preview and capture. This is defined as x,y for the top-left corner, and a width and height, with all values in normalised coordinates (0.0 - 1.0). So, to set a ROI at halfway across and down the sensor, and a width and height of a quarter of the sensor, use:

----
-roi 0.5,0.5,0.25,0.25
----

----
	--shutter,	-ss		Set shutter speed/time
----

Sets the shutter open time to the specified value (in microseconds). Shutter speed limits are as follows:

[cols="",^""]
|===
| Camera Version | Max (microseconds)

| V1 (OV5647)
| 6000000 (i.e. 6s)

| V2 (IMX219)
| 10000000 (i.e. 10s)

| HQ (IMX477)
| 200000000 (i.e. 200s)
|===

Using values above these maximums will result in undefined behaviour.

----
	--drc,	-drc		Enable/disable dynamic range compression
----

DRC changes the images by increasing the range of dark areas, and decreasing the brighter areas. This can improve the image in low light areas.

* off
* low
* med
* high

By default, DRC is off.

----
	--stats,	-st		Use stills capture frame for image statistics
----

Force recomputation of statistics on stills capture pass. Digital gain and AWB are recomputed based on the actual capture frame statistics, rather than the preceding preview frame.

----
	--awbgains,	-awbg
----

Sets blue and red gains (as floating point numbers) to be applied when `-awb off` is set e.g. -awbg 1.5,1.2

----
	--analoggain,	-ag
----

Sets the analog gain value directly on the sensor (floating point value from 1.0 to 8.0 for the OV5647 sensor on Camera Module V1, and 1.0 to 12.0 for the IMX219 sensor on Camera Module V2 and the IMX447 on the HQ Camera).

----
	--digitalgain,	-dg
----

Sets the digital gain value applied by the ISP (floating point value from 1.0 to 64.0, but values over about 4.0 will produce overexposed images)

----
	--mode,	-md
----

Sets a specified sensor mode, disabling the automatic selection. Possible values depend on the version of the Camera Module being used:

Version 1.x (OV5647)

|===
| Mode | Size | Aspect Ratio | Frame rates | FOV | Binning

| 0
| automatic selection
|
|
|
|

| 1
| 1920x1080
| 16:9
| 1-30fps
| Partial
| None

| 2
| 2592x1944
| 4:3
| 1-15fps
| Full
| None

| 3
| 2592x1944
| 4:3
| 0.1666-1fps
| Full
| None

| 4
| 1296x972
| 4:3
| 1-42fps
| Full
| 2x2

| 5
| 1296x730
| 16:9
| 1-49fps
| Full
| 2x2

| 6
| 640x480
| 4:3
| 42.1-60fps
| Full
| 2x2 plus skip

| 7
| 640x480
| 4:3
| 60.1-90fps
| Full
| 2x2 plus skip
|===

Version 2.x (IMX219)

|===
| Mode | Size | Aspect Ratio | Frame rates | FOV | Binning

| 0
| automatic selection
|
|
|
|

| 1
| 1920x1080
| 16:9
| 0.1-30fps
| Partial
| None

| 2
| 3280x2464
| 4:3
| 0.1-15fps
| Full
| None

| 3
| 3280x2464
| 4:3
| 0.1-15fps
| Full
| None

| 4
| 1640x1232
| 4:3
| 0.1-40fps
| Full
| 2x2

| 5
| 1640x922
| 16:9
| 0.1-40fps
| Full
| 2x2

| 6
| 1280x720
| 16:9
| 40-90fps
| Partial
| 2x2

| 7
| 640x480
| 4:3
| 40-200fps^1^
| Partial
| 2x2
|===

^1^For frame rates over 120fps, it is necessary to turn off automatic exposure and gain control using `-ex off`. Doing so should achieve the higher frame rates, but exposure time and gains will need to be set to fixed values supplied by the user.

HQ Camera

|===
| Mode | Size | Aspect Ratio | Frame rates | FOV | Binning/Scaling

| 0
| automatic selection
|
|
|
|

| 1
| 2028x1080
| 169:90
| 0.1-50fps
| Partial
| 2x2 binned

| 2
| 2028x1520
| 4:3
| 0.1-50fps
| Full
| 2x2 binned

| 3
| 4056x3040
| 4:3
| 0.005-10fps
| Full
| None

| 4
| 1332x990
| 74:55
| 50.1-120fps
| Partial
| 2x2 binned
|===

----
	--camselect,	-cs
----

Selects which camera to use on a multi-camera system. Use 0 or 1.

----
	--annotate,	-a		Enable/set annotate flags or text
----

Adds some text and/or metadata to the picture.

Metadata is indicated using a bitmask notation, so add them together to show multiple parameters. For example, 12 will show time(4) and date(8), since 4+8=12.

Text may include date/time placeholders by using the '%' character, as used by http://man7.org/linux/man-pages/man3/strftime.3.html[strftime].

|===
| Value | Meaning | Example Output

| -a 4
| Time
| 20:09:33

| -a 8
| Date
| 10/28/15

| -a 12
| 4+8=12 Show the date(4) and time(8)
| 20:09:33 10/28/15

| -a 16
| Shutter Settings
|

| -a 32
| CAF Settings
|

| -a 64
| Gain Settings
|

| -a 128
| Lens Settings
|

| -a 256
| Motion Settings
|

| -a 512
| Frame Number
|

| -a 1024
| Black Background
|

| -a ""ABC %Y-%m-%d %X""
| Show some text
| ABC %Y-%m-%d %X

| -a 4 -a ""ABC %Y-%m-%d %X""
| Show custom http://man7.org/linux/man-pages/man3/strftime.3.html[formatted] date/time
| ABC 2015-10-28 20:09:33

| -a 8 -a ""ABC %Y-%m-%d %X""
| Show custom http://man7.org/linux/man-pages/man3/strftime.3.html[formatted] date/time
| ABC 2015-10-28 20:09:33
|===

----
	--annotateex,	-ae		Set extra annotation parameters
----

Specifies annotation size, text colour, and background colour. Colours are in hex YUV format.

Size ranges from 6 - 160; default is 32. Asking for an invalid size should give you the default.

|===
| Example | Explanation

| -ae 32,0xff,0x808000 -a ""Annotation text""
| gives size 32 white text on black background

| -ae 10,0x00,0x8080FF -a ""Annotation text""
| gives size 10 black text on white background
|===

----
	--stereo,	-3d
----

Select the specified stereo imaging mode; `sbs` selects side-by-side mode, `tb` selects top/bottom mode; `off` turns off stereo mode (the default).

----
	--decimate,	-dec
----

Halves the width and height of the stereo image.

----
	--3dswap,	-3dswap
----

Swaps the camera order used in stereoscopic imaging; NOTE: currently not working.

----
	--settings,	-set
----

Retrieves the current camera settings and writes them to stdout.

=== Application-specific Settings

==== `raspistill`

----
	--width,	-w		Set image width <size>

	--height,	-h		Set image height <size>

	--quality,	-q		Set JPEG quality <0 to 100>
----

Quality 100 is almost completely uncompressed. 75 is a good all-round value.

----
	--raw,	-r		Add raw Bayer data to JPEG metadata
----

This option inserts the raw Bayer data from the camera into the JPEG metadata.

----
	--output,	-o		Output filename <filename>
----

Specifies the output filename. If not specified, no file is saved. If the filename is '-', then all output is sent to stdout.

----
	--latest,	-l		Link latest frame to filename <filename>
----

Makes a file system link under this name to the latest frame.

----
	--verbose,	-v		Output verbose information during run
----

Outputs debugging/information messages during the program run.

----
	--timeout,	-t		Time before the camera takes picture and shuts down
----

The program will run for the specified length of time, entered in milliseconds. It then takes the capture and saves it if an output is specified. If a timeout value is not specified, then it is set to 5 seconds (-t 5000). Note that low values (less than 500ms, although it can depend on other settings) may not give enough time for the camera to start up and provide enough frames for the automatic algorithms like AWB and AGC to provide accurate results.

If set to 0, the preview will run indefinitely, until stopped with CTRL-C. In this case no capture is made.

----
	--timelapse,	-tl		time-lapse mode
----

The specific value is the time between shots in milliseconds. Note that you should specify `%04d` at the point in the filename where you want a frame count number to appear. So, for example, the code below will produce a capture every 2 seconds, over a total period of 30s, named `image0001.jpg`, `image0002.jpg` and so on, through to `image0015.jpg`.

----
-t 30000 -tl 2000 -o image%04d.jpg
----

Note that the `%04d` indicates a 4-digit number, with leading zeroes added to make the required number of digits. So, for example, `%08d` would result in an 8-digit number.

If a time-lapse value of 0 is entered, the application will take pictures as fast as possible. Note that there's an minimum enforced pause of 30ms between captures to ensure that exposure calculations can be made.

----
	--framestart,	-fs
----

Specifies the first frame number in the timelapse. Useful if you have already saved a number of frames, and want to start again at the next frame.

----
	--datetime,	-dt
----

Instead of a simple frame number, the timelapse file names will use a date/time value of the format `aabbccddee`, where `aa` is the month, `bb` is the day of the month, `cc` is the hour, `dd` is the minute, and `ee` is the second.

----
	--timestamp,	-ts
----

Instead of a simple frame number, the timelapse file names will use a single number which is the Unix timestamp, i.e. the seconds since 1970.

----
	--thumb,	-th		Set thumbnail parameters (x:y:quality)
----

Allows specification of the thumbnail image inserted into the JPEG file. If not specified, defaults are a size of 64x48 at quality 35.

if `--thumb none` is specified, no thumbnail information will be placed in the file. This reduces the file size slightly.

----
	--demo,	-d		Run a demo mode <milliseconds>
----

This options cycles through the range of camera options. No capture is taken, and the demo will end at the end of the timeout period, irrespective of whether all the options have been cycled. The time between cycles should be specified as a millisecond value.

----
	--encoding,	-e		Encoding to use for output file
----

Valid options are `jpg`, `bmp`, `gif`, and `png`. Note that unaccelerated image types (GIF, PNG, BMP) will take much longer to save than jpg, which is hardware accelerated. Also note that the filename suffix is completely ignored when deciding the encoding of a file.

----
	--restart,	-rs
----

Sets the JPEG restart marker interval to a specific value. Can be useful for lossy transport streams because it allows a broken JPEG file to still be partially displayed.

----
	--exif,	-x		EXIF tag to apply to captures (format as 'key=value')
----

Allows the insertion of specific EXIF tags into the JPEG image. You can have up to 32 EXIF tag entries. This is useful for tasks like adding GPS metadata. For example, to set the longitude:

----
--exif GPS.GPSLongitude=5/1,10/1,15/1
----

would set the longitude to 5 degs, 10 minutes, 15 seconds. See EXIF documentation for more details on the range of tags available; the supported tags are as follows:

----
IFD0.<   or
IFD1.<
ImageWidth, ImageLength, BitsPerSample, Compression, PhotometricInterpretation, ImageDescription, Make, Model, StripOffsets, Orientation, SamplesPerPixel, RowsPerString, StripByteCounts, XResolution, YResolution, PlanarConfiguration, ResolutionUnit, TransferFunction, Software, DateTime, Artist, WhitePoint, PrimaryChromaticities, JPEGInterchangeFormat, JPEGInterchangeFormatLength, YCbCrCoefficients, YCbCrSubSampling, YCbCrPositioning, ReferenceBlackWhite, Copyright>

EXIF.<
ExposureTime, FNumber, ExposureProgram, SpectralSensitivity, ISOSpeedRatings, OECF, ExifVersion, DateTimeOriginal, DateTimeDigitized, ComponentsConfiguration, CompressedBitsPerPixel, ShutterSpeedValue, ApertureValue, BrightnessValue, ExposureBiasValue, MaxApertureValue, SubjectDistance, MeteringMode, LightSource, Flash, FocalLength, SubjectArea, MakerNote, UserComment, SubSecTime, SubSecTimeOriginal, SubSecTimeDigitized, FlashpixVersion, ColorSpace, PixelXDimension, PixelYDimension, RelatedSoundFile, FlashEnergy, SpatialFrequencyResponse, FocalPlaneXResolution, FocalPlaneYResolution, FocalPlaneResolutionUnit, SubjectLocation, ExposureIndex, SensingMethod, FileSource, SceneType, CFAPattern, CustomRendered, ExposureMode, WhiteBalance, DigitalZoomRatio, FocalLengthIn35mmFilm, SceneCaptureType, GainControl, Contrast, Saturation, Sharpness, DeviceSettingDescription, SubjectDistanceRange, ImageUniqueID>

GPS.<
GPSVersionID, GPSLatitudeRef, GPSLatitude, GPSLongitudeRef, GPSLongitude, GPSAltitudeRef, GPSAltitude, GPSTimeStamp, GPSSatellites, GPSStatus, GPSMeasureMode, GPSDOP, GPSSpeedRef, GPSSpeed, GPSTrackRef, GPSTrack, GPSImgDirectionRef, GPSImgDirection, GPSMapDatum, GPSDestLatitudeRef, GPSDestLatitude, GPSDestLongitudeRef, GPSDestLongitude, GPSDestBearingRef, GPSDestBearing, GPSDestDistanceRef, GPSDestDistance, GPSProcessingMethod, GPSAreaInformation, GPSDateStamp, GPSDifferential>

EINT.<
InteroperabilityIndex, InteroperabilityVersion, RelatedImageFileFormat, RelatedImageWidth, RelatedImageLength>
----

Note that a small subset of these tags will be set automatically by the camera system, but will be overridden by any EXIF options on the command line.

Setting `--exif none` will prevent any EXIF information being stored in the file. This reduces the file size slightly.

----
	--gpsdexif,	-gps
----

Applies real-time EXIF information from any attached GPS dongle (using GSPD) to the image; requires `libgps.so` to be installed.

----
	--fullpreview,	-fp		Full preview mode
----

This runs the preview window using the full resolution capture mode. Maximum frames per second in this mode is 15fps, and the preview will have the same field of view as the capture. Captures should happen more quickly, as no mode change should be required. This feature is currently under development.

----
	--keypress,	-k		Keypress mode
----

The camera is run for the requested time (`-t`), and a capture can be initiated throughout that time by pressing the Enter key. Pressing X then Enter will exit the application before the timeout is reached. If the timeout is set to 0, the camera will run indefinitely until the user presses X then Enter. Using the verbose option (`-v`) will display a prompt asking for user input, otherwise no prompt is displayed.

----
	--signal,	-s		Signal mode
----

The camera is run for the requested time (`-t`), and a capture can be initiated throughout that time by sending a `USR1` signal to the camera process. This can be done using the `kill` command. You can find the camera process ID using the `pgrep raspistill` command.

`kill -USR1 <process id of raspistill>`

----
	--burst,	-bm
----

Sets burst capture mode. This prevents the camera from returning to preview mode in between captures, meaning that captures can be taken closer together.

==== `raspivid`

----
	--width,	-w		Set image width <size>
----

Width of resulting video. This should be between 64 and 1920.

----
	--height,	-h		Set image height <size>
----

Height of resulting video. This should be between 64 and 1080.

----
	--bitrate,	-b		Set bitrate
----

Use bits per second, so 10Mbits/s would be `-b 10000000`. For H264, 1080p30 a high quality bitrate would be 15Mbits/s or more. Maximum bitrate is 25Mbits/s (`-b 25000000`), but much over 17Mbits/s won't show noticeable improvement at 1080p30.

----
	--output,	-o		Output filename <filename>
----

Specify the output filename. If not specified, no file is saved. If the filename is '-', then all output is sent to stdout.

To connect to a remote IPv4 host, use `tcp` or `udp` followed by the required IP Address. e.g. `tcp://192.168.1.2:1234` or `udp://192.168.1.2:1234`.

To listen on a TCP port (IPv4) and wait for an incoming connection use `--listen (-l)` option, e.g. `raspivid -l -o tcp://0.0.0.0:3333` will bind to all network interfaces, `raspivid -l -o tcp://192.168.1.1:3333` will bind to a local IPv4.

----
	--listen,	-l
----

When using a network connection as the data sink, this option will make the system wait for a connection from the remote system before sending data.

----
	--verbose,	-v		Output verbose information during run
----

Outputs debugging/information messages during the program run.

----
	--timeout,	-t		Time before the camera takes picture and shuts down
----

The total length of time that the program will run for. If not specified, the default is 5000ms (5 seconds). If set to 0, the application will run indefinitely until stopped with Ctrl-C.

----
	--demo,	-d		Run a demo mode <milliseconds>
----

This options cycles through the range of camera options. No recording is done, and the demo will end at the end of the timeout period, irrespective of whether all the options have been cycled. The time between cycles should be specified as a millisecond value.

----
	--framerate,	-fps		Specify the frames per second to record
----

At present, the minimum frame rate allowed is 2fps, and the maximum is 30fps. This is likely to change in the future.

----
	--penc,	-e		Display preview image after encoding
----

Switch on an option to display the preview after compression. This will show any compression artefacts in the preview window. In normal operation, the preview will show the camera output prior to being compressed. This option is not guaranteed to work in future releases.

----
	--intra,	-g		Specify the intra refresh period (key frame rate/GoP)
----

Sets the intra refresh period (GoP) rate for the recorded video. H264 video uses a complete frame (I-frame) every intra refresh period, from which subsequent frames are based. This option specifies the number of frames between each I-frame. Larger numbers here will reduce the size of the resulting video, and smaller numbers make the stream less error-prone.

----
	--qp,	-qp		Set quantisation parameter
----

Sets the initial quantisation parameter for the stream. Varies from approximately 10 to 40, and will greatly affect the quality of the recording. Higher values reduce quality and decrease file size. Combine this setting with a bitrate of 0 to set a completely variable bitrate.

----
	--profile,	-pf		Specify H264 profile to use for encoding
----

Sets the H264 profile to be used for the encoding. Options are:

* baseline
* main
* high

----
	--level,	-lev
----

Specifies the H264 encoder level to use for encoding. Options are `4`, `4.1`, and `4.2`.

----
	--irefresh,	-if
----

Sets the H264 intra-refresh type. Possible options are `cyclic`, `adaptive`, `both`, and `cyclicrows`.

----
	--inline,	-ih		Insert PPS, SPS headers
----

Forces the stream to include PPS and SPS headers on every I-frame. Needed for certain streaming cases e.g. Apple HLS. These headers are small, so don't greatly increase the file size.

----
	--spstimings,	-stm
----

Insert timing information into the SPS block.

----
	--timed,	-td		Do timed switches between capture and pause
----

This options allows the video capture to be paused and restarted at particular time intervals. Two values are required: the on time and the off time. On time is the amount of time the video is captured, and off time is the amount it is paused. The total time of the recording is defined by the `timeout` option. Note that the recording may take slightly over the timeout setting depending on the on and off times.

For example:

----
raspivid -o test.h264 -t 25000 -timed 2500,5000
----

will record for a period of 25 seconds. The recording will be over a timeframe consisting of 2500ms (2.5s) segments with 5000ms (5s) gaps, repeating over the 20s. So the entire recording will actually be only 10s long, since 4 segments of 2.5s = 10s separated by 5s gaps. So:

2.5 record -- 5 pause - 2.5 record -- 5 pause - 2.5 record -- 5 pause -- 2.5 record

gives a total recording period of 25s, but only 10s of actual recorded footage.

----
	--keypress,	-k		Toggle between record and pause on Enter keypress
----

On each press of the Enter key, the recording will be paused or restarted. Pressing X then Enter will stop recording and close the application. Note that the timeout value will be used to signal the end of recording, but is only checked after each Enter keypress; so if the system is waiting for a keypress, even if the timeout has expired, it will still wait for the keypress before exiting.

----
	--signal,	-s		Toggle between record and pause according to SIGUSR1
----

Sending a `USR1` signal to the `raspivid` process will toggle between recording and paused. This can be done using the `kill` command, as below. You can find the `raspivid` process ID using `pgrep raspivid`.

`kill -USR1 <process id of raspivid>`

Note that the timeout value will be used to indicate the end of recording, but is only checked after each receipt of the `SIGUSR1` signal; so if the system is waiting for a signal, even if the timeout has expired, it will still wait for the signal before exiting.

----
	--split,	-sp
----

When in a signal or keypress mode, each time recording is restarted, a new file is created.

----
	--circular,	-c
----

Select circular buffer mode. All encoded data is stored in a circular buffer until a trigger is activated, then the buffer is saved.

----
	--vectors,	-x
----

Turns on output of motion vectors from the H264 encoder to the specified file name.

----
	--flush,	-fl
----

Forces a flush of output data buffers as soon as video data is written. This bypasses any OS caching of written data, and can decrease latency.

----
	--save-pts,	-pts
----

Saves timestamp information to the specified file. Useful as an input file to `mkvmerge`.

----
	--codec,	-cd
----

Specifies the encoder codec to use. Options are `H264` and `MJPEG`. H264 can encode up to 1080p, whereas MJPEG can encode up to the sensor size, but at decreased framerates due to the higher processing and storage requirements.

----
	--initial,	-i		Define initial state on startup
----

Define whether the camera will start paused or will immediately start recording. Options are `record` or `pause`. Note that if you are using a simple timeout, and `initial` is set to `pause`, no output will be recorded.

----
	--segment,	-sg		Segment the stream into multiple files
----

Rather than creating a single file, the file is split into segments of approximately the number of milliseconds specified. In order to provide different filenames, you should add `%04d` or similar at the point in the filename where you want a segment count number to appear e.g:

----
--segment 3000 -o video%04d.h264
----

will produce video clips of approximately 3000ms (3s) long, named `video0001.h264`, `video0002.h264` etc. The clips should be seamless (no frame drops between clips), but the accuracy of each clip length will depend on the intraframe period, as the segments will always start on an I-frame. They will therefore always be equal or longer to the specified period.

The most recent version of Raspivid will also allow the file name to be time-based, rather than using a segment number. For example:

----
--segment 3000 -o video_%c.h264
----

will produce file names formatted like so: `video_Fri Jul 20 16:23:48 2018.h264`

There are http://man7.org/linux/man-pages/man3/strftime.3.html[many different formatting options] available. Note than the `%d` and `%u` options are not available, as they are used for the segment number formatting, and that some combinations may produce invalid file names.

----
	--wrap,	-wr		Set the maximum value for segment number
----

When outputting segments, this is the maximum the segment number can reach before it's reset to 1, giving the ability to keep recording segments, but overwriting the oldest one. So if set to 4, in the segment example above, the files produced will be `video0001.h264`, `video0002.h264`, `video0003.h264`, and `video0004.h264`. Once `video0004.h264` is recorded, the count will reset to 1, and `video0001.h264` will be overwritten.

----
	--start,	-sn		Set the initial segment number
----

When outputting segments, this is the initial segment number, giving the ability to resume a previous recording from a given segment. The default value is 1.

----
	--raw,	-r
----

Specify the output file name for any raw data files requested.

----
	--raw-format,	-rf
----

Specify the raw format to be used if raw output requested. Options as `yuv`, `rgb`, and `grey`. `grey` simply saves the Y channel of the YUV image.

==== `raspiyuv`

Many of the options for `raspiyuv` are the same as those for `raspistill`. This section shows the differences.

Unsupported options:

----
--exif, --encoding, --thumb, --raw, --quality
----

Extra options :

----
	--rgb,	-rgb		Save uncompressed data as RGB888
----

This option forces the image to be saved as RGB data with 8 bits per channel, rather than YUV420.

Note that the image buffers saved in `raspiyuv` are padded to a horizontal size divisible by 32, so there may be unused bytes at the end of each line. Buffers are also padded vertically to be divisible by 16, and in the YUV mode, each plane of Y,U,V is padded in this way.

----
	--luma,	-y
----

Only outputs the luma (Y) channel of the YUV image. This is effectively the black and white, or intensity, part of the image.

----
	--bgr,	-bgr
----

Saves the image data as BGR data rather than YUV.

=== Command Line Examples

==== Still Captures

By default, captures are done at the highest resolution supported by the sensor. This can be changed using the `-w` and `-h` command line options.

Take a default capture after 2s (times are specified in milliseconds) on the viewfinder, saving in `image.jpg`:

[,bash]
----
raspistill -t 2000 -o image.jpg
----

Take a capture at a different resolution:

[,bash]
----
raspistill -t 2000 -o image.jpg -w 640 -h 480
----

Reduce the quality considerably to reduce file size:

[,bash]
----
raspistill -t 2000 -o image.jpg -q 5
----

Force the preview to appear at coordinate 100,100, with width 300 pixels and height 200 pixels:

[,bash]
----
raspistill -t 2000 -o image.jpg -p 100,100,300,200
----

Disable preview entirely:

[,bash]
----
raspistill -t 2000 -o image.jpg -n
----

Save the image as a PNG file (lossless compression, but slower than JPEG). Note that the filename suffix is ignored when choosing the image encoding:

[,bash]
----
raspistill -t 2000 -o image.png –e png
----

Add some EXIF information to the JPEG. This sets the Artist tag name to Boris, and the GPS altitude to 123.5m. Note that if setting GPS tags you should set as a minimum GPSLatitude, GPSLatitudeRef, GPSLongitude, GPSLongitudeRef, GPSAltitude, and GPSAltitudeRef:

[,bash]
----
raspistill -t 2000 -o image.jpg -x IFD0.Artist=Boris -x GPS.GPSAltitude=1235/10
----

Set an emboss image effect:

[,bash]
----
raspistill -t 2000 -o image.jpg -ifx emboss
----

Set the U and V channels of the YUV image to specific values (128:128 produces a greyscale image):

[,bash]
----
raspistill -t 2000 -o image.jpg -cfx 128:128
----

Run preview for 2s, with no saved image:

[,bash]
----
raspistill -t 2000
----

Take a time-lapse picture, every 10 seconds for 10 minutes (10 minutes = 600000ms), naming the files `image_num_001_today.jpg`, `image_num_002_today.jpg` and so on, with the latest picture also available under the name `latest.jpg`:

[,bash]
----
raspistill -t 600000 -tl 10000 -o image_num_%03d_today.jpg -l latest.jpg
----

Take a picture and send the image data to stdout:

[,bash]
----
raspistill -t 2000 -o -
----

Take a picture and send the image data to a file:

[,bash]
----
raspistill -t 2000 -o - > my_file.jpg
----

Run the camera forever, taking a picture when Enter is pressed:

[,bash]
----
raspistill -t 0 -k -o my_pics%02d.jpg
----

==== Video captures

Image size and preview settings are the same as for stills capture. Default size for video recording is 1080p (1920x1080).

Record a 5s clip with default settings (1080p30):

[,bash]
----
raspivid -t 5000 -o video.h264
----

Record a 5s clip at a specified bitrate (3.5Mbits/s):

[,bash]
----
raspivid -t 5000 -o video.h264 -b 3500000
----

Record a 5s clip at a specified framerate (5fps):

[,bash]
----
raspivid -t 5000 -o video.h264 -f 5
----

Encode a 5s camera stream and send the image data to stdout:

[,bash]
----
raspivid -t 5000 -o -
----

Encode a 5s camera stream and send the image data to a file:

[,bash]
----
raspivid -t 5000 -o - > my_file.h264
----

=== Shell Error Codes

The applications described here will return a standard error code to the shell on completion. Possible error codes are:

|===
| C Define | Code | Description

| EX_OK
| 0
| Application ran successfully

| EX_USAGE
| 64
| Bad command line parameter

| EX_SOFTWARE
| 70
| Software or camera error

|
| 130
| Application terminated by Ctrl-C
|===

=== Long Exposures

The maximum exposure times of the three official Raspberry Pi cameras can be found in xref:camera.adoc#maximum-exposure-times[this table].

Due to the way the ISP works, by default asking for a long exposure can result in the capture process taking up to 7 times the exposure time, so a 200 second exposure on the HQ camera could take 1400 seconds to actually return an image. This is due to the way the camera system works out the correct exposures and gains to use in the image, using it's AGC (automatic gain control) and AWB (automatic white balance) algorithms. The system needs a few frames to calculate these numbers in order to produce a decent image. When combined with frame discards at the start of processing (in case they are corrupt), and the switching between preview and captures modes, this can result in up to 7 frames needed to produce a final image. With long exposures, that can take a long time.

Fortunately, the camera parameters can be altered to reduce frame time dramatically; however this means turning off the automatic algorithms and manually providing values for the AGC.

The AWB gains can usually be omitted as the legacy stack is able to reprocess the camera data to work them out (the `-st` option), though it is fine to specify them as well. Additionally, burst mode (`-bm`) with a short timeout should be requested to suppress the initial preview phase, and the exposure mode also needs disabling (`-ex off`).

The following example will perform a 100 second exposure capture

`raspistill -t 10 -bm -ex off -ag 1 -ss 100000000 -st -o long_exposure.jpg`

=== Shooting RAW using the Camera Modules

The definition of raw images can vary. The usual meaning is raw Bayer data directly from the sensor, although some may regard an uncompressed image that has passed through the ISP (and has therefore been processed) as raw. For the latter, we recommend using the term _unencoded_ so as to be clear about the difference.

Both options are available from the Raspberry Pi cameras.

==== Processed, Non-Lossy Images

The usual output from `raspistill` is a compressed JPEG file that has passed through all the stages of image processing to produce a high-quality image. However, JPEG, being a lossy format does throw away some information that the user may want.

`raspistill` has an `encoding` option that allows you to specify the output format: either `jpg`, `bmp`, `png` or `gif`. All but `jpg` are lossless, so no data is thrown away in an effort to improve compression, but do require conversion from the original YUV, and because these formats do not have hardware support they produce images slightly more slowly than JPEG.

e.g.

`raspistill --encoding png -o fred.png`

Another option is to output completely formatted YUV420 or RGB data using the xref:camera.adoc#raspiyuv[`raspiyuv`] application.

==== Unprocessed Images

For some applications, such as astrophotography, having the raw Bayer data direct from the sensor can be useful. This data will need to be post-processed to produce a useful image.

`raspistill` has a raw option that will cause the Bayer data to be output.

`raspistill --raw -o fred.jpg`

The raw data is appended to the end of the JPEG file and will https://www.raspberrypi.com/news/processing-raw-image-files-from-a-raspberry-pi-high-quality-camera/[need to be extracted].
",12460,True,2507.5448147805246,median
"[[FTPComponent]]
FTP/SFTP/FTPS Component
~~~~~~~~~~~~~~~~~~~~~~~

This component provides access to remote file systems over the FTP and
SFTP protocols.

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>
-----------------------------------------------------------------------

[Info]
====
More options

See link:file2.html[File] for more options as all the options from
link:file2.html[File] is inherited.

====

[Info]
====
Absolute paths

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.

====

[Tip]
====
Consuming from remote FTP server

Make sure you read the section titled _Default when consuming files_
further below for details related to consuming files.

====

[[FTP2-URIformat]]
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.

[[FTP2-URIOptions]]
URI Options
^^^^^^^^^^^

The options below are exclusive for the FTP component.

[Info]
====
More options

See link:file2.html[File] for more options as all the options from
link:file2.html[File] is inherited.

====

// component options: START
The FTP component has no options.
// component options: END









// endpoint options: START
The FTP component supports 105 endpoint options which are listed below:

{% raw %}
[width=""100%"",cols=""2,1,1m,1m,5"",options=""header""]
|=======================================================================
| Name | Group | Default | Java Type | Description
| host | common |  | String | *Required* Hostname of the FTP server
| port | common |  | int | Port of the FTP server
| directoryName | common |  | String | The starting directory
| binary | common | false | boolean | Specifies the file transfer mode BINARY or ASCII. Default is ASCII (false).
| charset | common |  | String | 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.
| disconnect | common | false | boolean | 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.
| doneFileName | common |  | String | 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.
| fileName | common |  | String | 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.
| passiveMode | common | false | boolean | Sets passive mode connections. Default is active mode connections.
| separator | common | UNIX | PathSeparator | 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
| fastExistsCheck | common (advanced) | false | boolean | 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.
| bridgeErrorHandler | consumer | false | boolean | Allows for bridging the consumer to the Camel routing Error Handler which mean any exceptions occurred while the consumer is trying to pickup incoming messages or the likes will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions that will be logged at WARN/ERROR level and ignored.
| delete | consumer | false | boolean | If true the file will be deleted after it is processed successfully.
| moveFailed | consumer |  | String | 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.
| noop | consumer | false | boolean | 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.
| preMove | consumer |  | String | 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.
| recursive | consumer | false | boolean | If a directory will look for files in all the sub-directories as well.
| sendEmptyMessageWhenIdle | consumer | false | boolean | If the polling consumer did not poll any files you can enable this option to send an empty message (no body) instead.
| streamDownload | consumer | false | boolean | 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.
| directoryMustExist | consumer (advanced) | false | boolean | Similar to startingDirectoryMustExist but this applies during polling recursive sub directories.
| download | consumer (advanced) | false | boolean | 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.
| exceptionHandler | consumer (advanced) |  | ExceptionHandler | 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/ERROR level and ignored.
| exchangePattern | consumer (advanced) |  | ExchangePattern | Sets the exchange pattern when the consumer creates an exchange.
| ignoreFileNotFoundOrPermissionError | consumer (advanced) | false | boolean | 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.
| inProgressRepository | consumer (advanced) |  | String> | 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.
| localWorkDirectory | consumer (advanced) |  | String | 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.
| onCompletionExceptionHandler | consumer (advanced) |  | ExceptionHandler | 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.
| pollStrategy | consumer (advanced) |  | PollingConsumerPollStrategy | 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.
| processStrategy | consumer (advanced) |  | GenericFileProcessStrategy<T> | 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.
| receiveBufferSize | consumer (advanced) | 32768 | int | The receive (download) buffer size Used only by FTPClient
| startingDirectoryMustExist | consumer (advanced) | false | boolean | 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.
| useList | consumer (advanced) | true | boolean | 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.
| fileExist | producer | Override | GenericFileExist | 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.
| flatten | producer | false | boolean | 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.
| moveExisting | producer |  | String | 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.
| tempFileName | producer |  | String | 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.
| tempPrefix | producer |  | String | 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.
| allowNullBody | producer (advanced) | false | boolean | 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.
| chmod | producer (advanced) |  | String | Allows you to set chmod on the stored file. For example chmod=640.
| disconnectOnBatchComplete | producer (advanced) | false | boolean | 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.
| eagerDeleteTargetFile | producer (advanced) | true | boolean | 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.
| keepLastModified | producer (advanced) | false | boolean | 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.
| sendNoop | producer (advanced) | true | boolean | 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.
| activePortRange | advanced |  | String | 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.
| autoCreate | advanced | true | boolean | 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.
| bufferSize | advanced | 131072 | int | Write buffer sized in bytes.
| connectTimeout | advanced | 10000 | int | Sets the connect timeout for waiting for a connection to be established Used by both FTPClient and JSCH
| ftpClient | advanced |  | FTPClient | To use a custom instance of FTPClient
| ftpClientConfig | advanced |  | FTPClientConfig | To use a custom instance of FTPClientConfig to configure the FTP client the endpoint should use.
| ftpClientConfigParameters | advanced |  | Map | Used by FtpComponent to provide additional parameters for the FTPClientConfig
| ftpClientParameters | advanced |  | Map | Used by FtpComponent to provide additional parameters for the FTPClient
| maximumReconnectAttempts | advanced |  | int | Specifies the maximum reconnect attempts Camel performs when it tries to connect to the remote FTP server. Use 0 to disable this behavior.
| reconnectDelay | advanced |  | long | Delay in millis Camel will wait before performing a reconnect attempt.
| siteCommand | advanced |  | String | Sets optional site command(s) to be executed after successful login. Multiple site commands can be separated using a new line character (\\n).
| soTimeout | advanced | 300000 | int | Sets the so timeout Used only by FTPClient
| stepwise | advanced | true | boolean | 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.
| synchronous | advanced | false | boolean | Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported).
| throwExceptionOnConnectFailed | advanced | false | boolean | 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.
| timeout | advanced | 30000 | int | Sets the data timeout for waiting for reply Used only by FTPClient
| antExclude | filter |  | String | 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.
| antFilterCaseSensitive | filter | true | boolean | Sets case sensitive flag on ant fiter
| antInclude | filter |  | String | Ant style filter inclusion. Multiple inclusions may be specified in comma-delimited format.
| eagerMaxMessagesPerPoll | filter | true | boolean | 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.
| exclude | filter |  | String | 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
| filter | filter |  | GenericFileFilter<T> | Pluggable filter as a org.apache.camel.component.file.GenericFileFilter class. Will skip files if filter returns false in its accept() method.
| filterDirectory | filter |  | String | 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
| filterFile | filter |  | String | Filters the file based on Simple language. For example to filter on file size you can use $file:size 5000
| idempotent | filter | false | Boolean | 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.
| idempotentKey | filter |  | String | 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
| idempotentRepository | filter |  | String> | A pluggable repository org.apache.camel.spi.IdempotentRepository which by default use MemoryMessageIdRepository if none is specified and idempotent is true.
| include | filter |  | String | Is used to include 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
| maxDepth | filter | 2147483647 | int | The maximum depth to traverse when recursively processing a directory.
| maxMessagesPerPoll | filter |  | int | 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.
| minDepth | filter |  | int | 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.
| move | filter |  | String | 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.
| exclusiveReadLockStrategy | lock |  | GenericFileExclusiveReadLockStrategy<T> | Pluggable read-lock as a org.apache.camel.component.file.GenericFileExclusiveReadLockStrategy implementation.
| readLock | lock |  | String | 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.
| readLockCheckInterval | lock | 1000 | long | 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.
| readLockDeleteOrphanLockFiles | lock | true | boolean | 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.
| readLockLoggingLevel | lock | WARN | LoggingLevel | 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 rename.
| readLockMarkerFile | lock | true | boolean | 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.
| readLockMinAge | lock | 0 | long | 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.
| readLockMinLength | lock | 1 | long | 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.
| readLockRemoveOnCommit | lock | false | boolean | 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.
| readLockRemoveOnRollback | lock | true | boolean | 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).
| readLockTimeout | lock | 10000 | long | 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.
| backoffErrorThreshold | scheduler |  | int | The number of subsequent error polls (failed due some error) that should happen before the backoffMultipler should kick-in.
| backoffIdleThreshold | scheduler |  | int | The number of subsequent idle polls that should happen before the backoffMultipler should kick-in.
| backoffMultiplier | scheduler |  | int | 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.
| delay | scheduler | 500 | long | 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).
| greedy | scheduler | false | boolean | If greedy is enabled then the ScheduledPollConsumer will run immediately again if the previous run polled 1 or more messages.
| initialDelay | scheduler | 1000 | long | 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).
| runLoggingLevel | scheduler | TRACE | LoggingLevel | The consumer logs a start/complete log line when it polls. This option allows you to configure the logging level for that.
| scheduledExecutorService | scheduler |  | ScheduledExecutorService | Allows for configuring a custom/shared thread pool to use for the consumer. By default each consumer has its own single threaded thread pool.
| scheduler | scheduler | none | ScheduledPollConsumerScheduler | To use a cron scheduler from either camel-spring or camel-quartz2 component
| schedulerProperties | scheduler |  | Map | To configure additional properties when using a custom scheduler or any of the Quartz2 Spring based scheduler.
| startScheduler | scheduler | true | boolean | Whether the scheduler should be auto started.
| timeUnit | scheduler | MILLISECONDS | TimeUnit | Time unit for initialDelay and delay options.
| useFixedDelay | scheduler | true | boolean | Controls if fixed delay or fixed rate is used. See ScheduledExecutorService in JDK for details.
| shuffle | sort | false | boolean | To shuffle the list of files (sort in random order)
| sortBy | sort |  | String | 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.
| sorter | sort |  | GenericFile<T>> | Pluggable sorter as a java.util.Comparator class.
| account | security |  | String | Account to use for login
| password | security |  | String | Password to use for login
| username | security |  | String | Username to use for login
|=======================================================================
{% endraw %}
// endpoint options: END










[Info]
====
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"");
------------------------------------------------------------------------------------

[[FTP2-MoreURIoptions]]
More URI options
^^^^^^^^^^^^^^^^

[Info]
====


See link:file2.html[File2] as all the options there also applies for
this component.

====

[[FTP2-Examples]]
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`

[Warning]
====
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.

====

[Tip]
====
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.

====

[[FTP2-Defaultwhenconsumingfiles]]
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.

[[FTP2-limitations]]
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.

[[FTP2-MessageHeaders]]
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
|=======================================================================

[[FTP2-Abouttimeouts]]
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.

[[FTP2-UsingLocalWorkDirectory]]
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.

====

[[FTP2-Stepwisechangingdirectories]]
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.

[[FTP2-Usingstepwise]]
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.

[[FTP2-Notusingstepwise]]
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.

[[FTP2-Samples]]
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>
------------------------------------------------------------------------------------------------------

[[FTP2-ConsumingaremoteFTPSserverimplicitSSLandclientauthentication]]
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"");
--------------------------------------------------------------------------------------------------

[[FTP2-ConsumingaremoteFTPSserverexplicitTLSandacustomtruststoreconfiguration]]
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"");
----------------------------------------------------------------------------------------------------------------------------------------------------------------

[[FTP2-Filterusingorg.apache.camel.component.file.GenericFileFilter]]
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>
---------------------------------------------------------------------------------------

[[FTP2-FilteringusingANTpathmatcher]]
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:

[[FTP2-UsingaproxywithSFTP]]
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.

[[FTP2-SettingpreferredSFTPauthenticationmethod]]
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"");
-------------------------------------------------------------------------------------------------------------

[[FTP2-Consumingasinglefileusingafixedname]]
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);
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

[[FTP2-Debuglogging]]
Debug logging
^^^^^^^^^^^^^

This component has log level *TRACE* that can be helpful if you have
problems.

[[FTP2-SeeAlso]]
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]

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

#include ""extprocess.h""
//#include ""logger.h""
#include <dbLogger.h>

namespace rcx {

extConductor::extConductor()
{
  strcpy(_name, """");
  _height          = 0;
  _distance        = 0;
  _thickness       = 0;
  _min_width       = 0;
  _min_spacing     = 0;
  _origin_x        = 0;
  _bottom_left_x   = 0;
  _bottom_right_x  = 0;
  _top_left_x      = 0;
  _top_right_x     = 0;
  _var_table_index = 0;
  _p               = 0.0;
  _min_cw_del      = 0;
  _max_cw_del      = 0;
  _min_ct_del      = 0;
  _max_ct_del      = 0;
  _min_ca          = 0;
  _max_ca          = 0;
  _top_ext         = 0;
  _bot_ext         = 0;
}
void extConductor::printConductor(FILE* fp, Ath__parser* parse)
{
  fprintf(fp, ""CONDUCTOR {\\n"");

  parse->printString(fp, ""\\t"", ""name"", _name);
  parse->printDouble(fp, ""\\t"", ""height"", _height, true);
  parse->printDouble(fp, ""\\t"", ""thickness"", _thickness, true);

  parse->printDouble(fp, ""\\t"", ""min_width"", _min_width, true);
  parse->printDouble(fp, ""\\t"", ""min_spacing"", _min_spacing, true);
  parse->printDouble(fp, ""\\t"", ""origin_x"", _origin_x, true);
  parse->printDouble(fp, ""\\t"", ""bottom_left_x"", _bottom_left_x, true);
  parse->printDouble(fp, ""\\t"", ""bottom_right_x"", _bottom_right_x, true);
  parse->printDouble(fp, ""\\t"", ""top_left_x"", _top_left_x, true);
  parse->printDouble(fp, ""\\t"", ""top_right_x"", _top_right_x, true);
  parse->printDouble(fp, ""\\t"", ""top_extension"", _top_ext, false);
  parse->printDouble(fp, ""\\t"", ""bottom_extension"", _bot_ext, false);
  parse->printInt(fp, ""\\t"", ""var_table"", _var_table_index, true);
  parse->printDouble(fp, ""\\t"", ""resistivity"", _p, true);

  fprintf(fp, ""}\\n"");
}
bool extConductor::readConductor(Ath__parser* parser)
{
  if (parser->setDoubleVal(""distance"", 1, _distance))
    return true;
  else if (parser->setDoubleVal(""height"", 1, _height))
    return true;
  else if (parser->setDoubleVal(""thickness"", 1, _thickness))
    return true;
  else if (parser->setDoubleVal(""min_width"", 1, _min_width))
    return true;
  else if (parser->setDoubleVal(""min_spacing"", 1, _min_spacing))
    return true;
  else if (parser->setDoubleVal(""origin_x"", 1, _origin_x))
    return true;
  else if (parser->setDoubleVal(""bottom_left_x"", 1, _bottom_left_x))
    return true;
  else if (parser->setDoubleVal(""bottom_right_x"", 1, _bottom_right_x))
    return true;
  else if (parser->setDoubleVal(""top_left_x"", 1, _top_left_x))
    return true;
  else if (parser->setDoubleVal(""top_right_x"", 1, _top_right_x))
    return true;
  else if (parser->setIntVal(""var_table"", 1, _var_table_index))
    return true;
  else if (parser->setDoubleVal(""resistivity"", 1, _p))
    return true;
  else if (parser->setDoubleVal(""min_cw_del"", 1, _min_cw_del))
    return true;
  else if (parser->setDoubleVal(""max_cw_del"", 1, _max_cw_del))
    return true;
  else if (parser->setDoubleVal(""min_ct_del"", 1, _min_ct_del))
    return true;
  else if (parser->setDoubleVal(""max_ct_del"", 1, _max_ct_del))
    return true;
  else if (parser->setDoubleVal(""min_ca"", 1, _min_ca))
    return true;
  else if (parser->setDoubleVal(""max_ca"", 1, _max_ca))
    return true;
  else if (parser->setDoubleVal(""top_extension"", 1, _top_ext))
    return true;
  else if (parser->setDoubleVal(""bottom_extension"", 1, _bot_ext))
    return true;

  return false;
}

extDielectric::extDielectric()
{
  strcpy(_name, """");
  strcpy(_non_conformal_metal, """");
  _epsilon          = 0;
  _height           = 0;
  _distance         = 0;
  _thickness        = 0;
  _left_thickness   = 0;
  _right_thickness  = 0;
  _top_thickness    = 0;
  _bottom_thickness = 0;
  _conformal        = false;
  _trench           = false;
  _bottom_ext       = 0;
  _slope            = 0;
  _met              = 0;
  _nextMet          = 0;
}
void extDielectric::printDielectric(FILE* fp, Ath__parser* parse)
{
  fprintf(fp, ""DIELECTRIC {\\n"");

  parse->printString(fp, ""\\t"", ""name"", _name);
  parse->printDouble(fp, ""\\t"", ""epsilon"", _epsilon);
  if (!_conformal && !_trench)
    parse->printString(
        fp, ""\\t"", ""non_conformal_metal"", _non_conformal_metal, true);

  parse->printDouble(fp, ""\\t"", ""height"", _height, true);
  parse->printDouble(fp, ""\\t"", ""thickness"", _thickness, true);

  parse->printDouble(fp, ""\\t"", ""left_thickness"", _left_thickness, true);
  parse->printDouble(fp, ""\\t"", ""right_thickness"", _right_thickness, true);
  parse->printDouble(fp, ""\\t"", ""top_thickness"", _top_thickness, true);
  parse->printDouble(fp, ""\\t"", ""bottom_thickness"", _bottom_thickness, true);
  parse->printDouble(fp, ""\\t"", ""bottom_ext"", _bottom_ext, true);
  parse->printDouble(fp, ""\\t"", ""slope"", _slope, false);
  parse->printInt(fp, ""\\t"", ""met"", _met, true);
  parse->printInt(fp, ""\\t"", ""next_met"", _nextMet, true);

  fprintf(fp, ""}\\n"");
}
void extDielectric::printDielectric(FILE* fp,
                                    float planeWidth,
                                    float planeThickness)
{
  fprintf(fp,
          ""BOX NAME %-15s; CX=0; CY=%g; W=%g; H= %g; DIEL= %g;\\n"",
          _name,
          _height,
          planeWidth,
          planeThickness,
          _epsilon);
}
void extDielectric::printDielectric3D(FILE* fp,
                                      float blockWidth,
                                      float blockThickness,
                                      float blockLength)
{
  fprintf(fp,
          ""BLOCK NAME %-15s; V1=0,%g,%g; LENGTH=%g; WIDTH=%g; HEIGHT=%g; ""
          ""DIEL=%g;\\n"",
          _name,
          _height - (blockThickness * 0.5),
          blockLength * 0.5,
          blockThickness,
          blockWidth,
          blockLength,
          _epsilon);
}
void extMasterConductor::writeRaphaelDielPoly(FILE*          fp,
                                              double         X,
                                              double         width,
                                              extDielectric* diel)
{
  fprintf(fp, ""POLY NAME= %s; "", diel->_name);

  fprintf(fp, "" COORD= "");

  writeRaphaelPointXY(fp, X + _loLeft[0], _loLeft[2]);
  writeRaphaelPointXY(fp, X + _loRight[0], _loLeft[2]);
  writeRaphaelPointXY(fp, X + _hiRight[0], _hiRight[2]);
  writeRaphaelPointXY(fp, X + _hiLeft[0], _hiLeft[2]);

  fprintf(fp, "" DIEL=%g ;\\n"", diel->_epsilon);
}
void extMasterConductor::writeRaphaelDielPoly3D(FILE*          fp,
                                                double         X,
                                                double         width,
                                                double         length,
                                                extDielectric* diel)
{
  fprintf(fp, ""POLY3D NAME= %s; "", diel->_name);

  fprintf(fp, "" COORD= "");

  writeRaphaelPointXY(fp, X + _loLeft[0], _loLeft[2]);
  writeRaphaelPointXY(fp, X + _loRight[0], _loLeft[2]);
  writeRaphaelPointXY(fp, X + _hiRight[0], _hiRight[2]);
  writeRaphaelPointXY(fp, X + _hiLeft[0], _hiLeft[2]);

  fprintf(fp, ""V1=0,0,0; HEIGHT=%g;"", length);
  fprintf(fp, "" DIEL=%g ;\\n"", diel->_epsilon);
}
void extMasterConductor::printDielBox(FILE*          fp,
                                      double         X,
                                      double         width,
                                      extDielectric* diel,
                                      const char*    width_name)
{
  // non conformal

  double thickness = _hiLeft[2] - _loLeft[2];
  if (thickness == 0.0)
    return;
  if (width_name != NULL) {
    double height = _loLeft[2];

    fprintf(fp,
            ""BOX NAME=%-15s; CX=0; CY=%6.3f; W=%s; H= %.3f; DIEL= %g;\\n"",
            diel->_name,
            height,
            width_name,
            thickness,
            diel->_epsilon);

    /*		fprintf(stdout, ""BOX NAME=%-15s; CX=0; CY=%6.3f; W=%s; H= %.3f;
       DIEL= %g;\\n"", diel->_name, height, width_name, thickness,
       diel->_epsilon);
    */
    odb::notice(0,
                ""BOX NAME=%-15s; CX=0; CY=%6.3f; W=%s; H= %.3f; DIEL= %g;\\n"",
                diel->_name,
                height,
                width_name,
                thickness,
                diel->_epsilon);
  } else {
    _loRight[0] = _loLeft[0] + width;
    _hiRight[0] = _hiLeft[0] + width;

    writeRaphaelDielPoly(fp, X, width, diel);

    // writeRaphaelDielPoly(stdout, X, width, diel);
  }
}
void extMasterConductor::printDielBox3D(FILE*          fp,
                                        double         X,
                                        double         width,
                                        double         length,
                                        extDielectric* diel,
                                        const char*    width_name)
{
  // non conformal

  if (width_name != NULL) {
    //                double height= _loLeft[2];
    double thickness = _hiLeft[2] - _loLeft[2];

    fprintf(fp,
            ""BLOCK NAME=%-15s; V1=0,0,%6.3f; WIDTH=%s; LENGTH= %.3f; ""
            ""HEIGHT=%6.3f; DIEL= %g;\\n"",
            diel->_name,
            0.5 * length,
            width_name,
            thickness,
            length,
            diel->_epsilon);
    /*        	fprintf(stdout, ""BLOCK NAME=%-15s; V1=0,0,%6.3f; WIDTH=%s;
       LENGTH= %.3f; HEIGHT=%6.3f; DIEL= %g;\\n"", diel->_name, 0.5*length,
       width_name, thickness, length, diel->_epsilon);
    */
    odb::notice(0,
                ""BLOCK NAME=%-15s; V1=0,0,%6.3f; WIDTH=%s; LENGTH= %.3f; ""
                ""HEIGHT=%6.3f; DIEL= %g;\\n"",
                diel->_name,
                0.5 * length,
                width_name,
                thickness,
                length,
                diel->_epsilon);
  } else {
    _loRight[0] = _loLeft[0] + width;
    _hiRight[0] = _hiLeft[0] + width;

    writeRaphaelDielPoly3D(fp, X, width, length, diel);
  }
}
void extProcess::writeProcess(FILE* fp,
                              char* gndName,
                              float planeWidth,
                              float planeThickness)
{
  fprintf(fp,
          ""WINDOW X1=%g; Y1=-1.0; X2=%g; Y2=%g; DIEL=1.0;\\n"",
          -planeWidth * 0.5,
          planeWidth * 0.5,
          planeThickness);

  for (uint jj = 1; jj < _dielTable->getCnt(); jj++) {
    extDielectric* diel = _dielTable->get(jj);
    //		if (diel->_conformal)
    diel->printDielectric(fp, planeWidth, planeThickness);
  }
  fprintf(fp,
          ""BOX NAME=%s CX=0; CY=-0.5; W=%g; H=1.0; VOLT=0.0;\\n"",
          gndName,
          planeWidth);

  fprintf(fp, ""OPTIONS SET_GRID=10000;\\n"");
}
void extProcess::writeProcess3D(FILE* fp,
                                char* gndName,
                                float blockWidth,
                                float blockThickness,
                                float blockLength)
{
  fprintf(fp,
          ""WINDOW3D V1=%g,0,0; V2=%g,%g,%g; DIEL=1.0;\\n"",
          -blockWidth * 0.5,
          blockWidth * 0.5,
          blockThickness,
          blockLength);

  for (uint jj = 1; jj < _dielTable->getCnt(); jj++) {
    extDielectric* diel = _dielTable->get(jj);
    //                if (diel->_conformal)
    diel->printDielectric3D(fp, blockWidth, blockThickness, blockLength);
  }
  fprintf(
      fp,
      ""BLOCK NAME=%s; V1=0,-1,%g; LENGTH=1.0; WIDTH=%g, HEIGHT=%g; VOLT=0.0;\\n"",
      gndName,
      blockLength * 0.5,
      blockWidth,
      blockLength);

  fprintf(fp, ""OPTIONS SET_GRID=1000000;\\n"");
}
void extProcess::writeParam(FILE* fp, const char* name, double val)
{
  fprintf(fp, ""param %s=%g;\\n"", name, val);
}
void extProcess::writeWindow(FILE*       fp,
                             const char* param_width_name,
                             double      y1,
                             const char* param_thickness_name)
{
  fprintf(fp, ""\\n$ Simulation window\\n"");
  fprintf(fp,
          ""WINDOW X1=-0.5*%s; Y1=%g; X2=0.5*%s; Y2=%s; DIEL=1.0;\\n"",
          param_width_name,
          y1,
          param_width_name,
          param_thickness_name);
}
void extProcess::writeWindow3D(FILE*       fp,
                               const char* param_width_name,
                               double      y1,
                               const char* param_thickness_name,
                               const char* param_length_name)
{
  fprintf(fp, ""\\n$ Simulation window\\n"");
  fprintf(fp,
          ""WINDOW3D V1=-0.5*%s,%g,0; V2=0.5*%s,%s,%s; DIEL=1.0;\\n"",
          param_width_name,
          y1,
          param_width_name,
          param_thickness_name,
          param_length_name);
}
void extProcess::writeGround(FILE*       fp,
                             int         met,
                             const char* name,
                             double      width,
                             double      x1,
                             double      volt,
                             bool        diag)
{
  if (met < 0)
    return;
  if (!met && diag)
    return;

  double              y1 = -1.0;
  double              th = 1.0;
  extMasterConductor* m;
  if (met > 0 && !diag) {
    m  = getMasterConductor(met);
    y1 = m->_loLeft[2];
    th = m->_hiLeft[2] - y1;
    m->writeRaphaelConformalGround(fp, x1, width, this);
    fprintf(fp, ""POLY NAME= M%d__%s; "", met, name);
  } else {
    fprintf(fp, ""POLY NAME= M0__%s; "", name);
  }

  fprintf(fp, "" COORD= "");

  writeRaphaelPointXY(fp, x1, y1);
  writeRaphaelPointXY(fp, x1 + width, y1);
  writeRaphaelPointXY(fp, x1 + width, y1 + th);
  writeRaphaelPointXY(fp, x1, y1 + th);

  fprintf(fp, "" VOLT=%g ;\\n"", volt);

  fprintf(fp, ""OPTIONS SET_GRID=10000;\\n\\n"");
}
void extProcess::writeGround3D(FILE*       fp,
                               int         met,
                               const char* name,
                               double      width,
                               double      length,
                               double      x1,
                               double      volt,
                               bool        diag)
{
  if (met < 0)
    return;

  double y1 = -1.0;
  double th = 1.0;
  if (!met || diag) {
    if (diag)
      fprintf(fp, ""POLY3D NAME= M0__w0; "");
    else
      fprintf(fp, ""POLY3D NAME= M%d__w0; "", met);
    fprintf(fp, "" COORD= "");
    writeRaphaelPointXY(fp, x1, y1);
    writeRaphaelPointXY(fp, x1 + width, y1);
    writeRaphaelPointXY(fp, x1 + width, y1 + th);
    writeRaphaelPointXY(fp, x1, y1 + th);
    fprintf(fp, "" V1=0,0,0; HEIGHT=%g;"", length);
    fprintf(fp, "" VOLT=%g ;\\n"", volt);
    fprintf(fp, ""OPTIONS SET_GRID=1000000;\\n\\n"");
    return;
  }

  double w, s, p;
  if (met > 0) {
    extMasterConductor* m = getMasterConductor(met);
    y1                    = m->_loLeft[2];
    th                    = m->_hiLeft[2] - y1;
    w                     = getConductor(met)->_min_width;
    s                     = getConductor(met)->_min_spacing;
    p                     = w + s;
  }

  double l   = 2 * p;
  double end = length - 2 * p;
  while (l <= end) {
    fprintf(fp, ""POLY3D NAME= M%d__w0; "", met);
    fprintf(fp, "" COORD= "");
    writeRaphaelPointXY(fp, x1, y1);
    writeRaphaelPointXY(fp, x1 + width, y1);
    writeRaphaelPointXY(fp, x1 + width, y1 + th);
    writeRaphaelPointXY(fp, x1, y1 + th);

    fprintf(fp, "" V1=0,0,%g; HEIGHT=%g;"", l, w);
    fprintf(fp, "" VOLT=%g ;\\n"", volt);
    l += p;
  }

  fprintf(fp, ""OPTIONS SET_GRID=1000000;\\n\\n"");
}
void extProcess::writeGround(FILE*       fp,
                             int         met,
                             const char* name,
                             const char* param_width_name,
                             double      x1,
                             double      volt)
{
  if (met < 0)
    return;

  double y1 = -0.5;
  double th = 1.0;
  if (met > 0) {
    extMasterConductor* m = getMasterConductor(met);
    y1                    = m->_loLeft[2];
    th                    = m->_hiLeft[2] - y1;
  }
  fprintf(fp,
          ""BOX NAME=M%d__%s CX=%g; CY=%g; W=%s; H=%g; VOLT=%g;\\n"",
          met,
          name,
          x1,
          y1,
          param_width_name,
          th,
          volt);

  fprintf(fp, ""OPTIONS SET_GRID=10000;\\n\\n"");
}
void extProcess::writeFullProcess(FILE*  fp,
                                  double X,
                                  double width,
                                  char*  width_name)
{
  for (uint jj = 1; jj < _masterDielectricTable->getCnt(); jj++) {
    extMasterConductor* m    = _masterDielectricTable->get(jj);
    extDielectric*      diel = _dielTable->get(m->_condId);

    // if (diel->_conformal)
    m->printDielBox(fp, X, width, diel, width_name);
  }
}
void extProcess::writeFullProcess3D(FILE*  fp,
                                    double X,
                                    double width,
                                    double length,
                                    char*  width_name)
{
  for (uint jj = 1; jj < _masterDielectricTable->getCnt(); jj++) {
    extMasterConductor* m    = _masterDielectricTable->get(jj);
    extDielectric*      diel = _dielTable->get(m->_condId);

    // if (diel->_conformal)
    m->printDielBox3D(fp, X, width, length, diel, width_name);
  }
}
void extProcess::writeFullProcess(FILE*  fp,
                                  char*  gndName,
                                  double planeWidth,
                                  double planeThickness)
{
  fprintf(fp, ""param plane_width=%g;\\n"", planeWidth);

  fprintf(fp,
          ""WINDOW X1=%g; Y1=-1.0; X2=%g; Y2=%g; DIEL=1.0;\\n"",
          -planeWidth * 0.5,
          planeWidth * 0.5,
          planeThickness);

  for (uint jj = 1; jj < _masterDielectricTable->getCnt(); jj++) {
    extMasterConductor* m    = _masterDielectricTable->get(jj);
    extDielectric*      diel = _dielTable->get(m->_condId);

    // if (diel->_conformal)
    m->printDielBox(fp, 0.0, planeWidth, diel, ""plane_width"");
  }
  fprintf(fp,
          ""\\nBOX NAME=%s CX=0; CY=-0.5; W=%g; H=1.0; VOLT=0.0;\\n"",
          gndName,
          planeWidth);

  fprintf(fp, ""OPTIONS SET_GRID=10000;\\n\\n"");
}

void extProcess::writeProcessAndGround(FILE*       wfp,
                                       const char* gndName,
                                       int         underMet,
                                       int         overMet,
                                       double      X,
                                       double      width,
                                       double      thickness,
                                       bool        diag)
{
  const char* widthName     = ""window_width"";
  const char* thicknessName = ""window_thichness"";

  writeParam(wfp, widthName, width);
  writeParam(wfp, thicknessName, thickness);

  // CX,CY bug : writeFullProcess(wfp, X, width, widthName);
  writeFullProcess(wfp, X, width, NULL);

  double y1 = 0.0;
  writeWindow(wfp, widthName, y1, thicknessName);

  fprintf(wfp, ""\\n$ Ground Plane(s)\\n"");
  //	writeGround(wfp, underMet, gndName, widthName, 0.0, 0.0);
  //	writeGround(wfp, overMet, gndName, widthName, 0.0, 0.0);

  writeGround(wfp, underMet, gndName, width, -0.5 * width, 0.0, diag);
  writeGround(wfp, overMet, gndName, width, -0.5 * width, 0.0, diag);
}
void extProcess::writeProcessAndGround3D(FILE*       wfp,
                                         const char* gndName,
                                         int         underMet,
                                         int         overMet,
                                         double      X,
                                         double      width,
                                         double      length,
                                         double      thickness,
                                         double      W,
                                         bool        diag)
{
  double wid, x;
  if (width > W) {
    wid = width;
    x   = X;
  } else {
    wid = W + 10.0;
    x   = -wid * 0.5;
  }
  const char* widthName     = ""window_width"";
  const char* thicknessName = ""window_thichness"";
  const char* lengthName    = ""window_length"";

  writeParam(wfp, widthName, wid);
  writeParam(wfp, thicknessName, thickness);
  writeParam(wfp, lengthName, length);

  // CX,CY bug : writeFullProcess(wfp, X, width, widthName);
  writeFullProcess3D(wfp, x, width, length, NULL);

  double y1 = 0.0;
  writeWindow3D(wfp, widthName, y1, thicknessName, lengthName);

  fprintf(wfp, ""\\n$ Ground Plane(s)\\n"");

  writeGround3D(wfp, 0, gndName, wid, length, -0.5 * wid, 0.0);

  double w, s, offset;

  if (underMet > 0) {
    w      = getConductor(underMet)->_min_width;
    s      = getConductor(underMet)->_min_spacing;
    offset = w + s;
    wid    = W + 2 * offset;
    writeGround3D(wfp, underMet, gndName, wid, length, -0.5 * wid, 0.0);
  }
  if (overMet > 0) {
    w      = getConductor(overMet)->_min_width;
    s      = getConductor(overMet)->_min_spacing;
    offset = w + s;
    wid    = W + 2 * offset;
    writeGround3D(wfp, overMet, gndName, wid, length, -0.5 * wid, 0.0);
  }
}
bool extDielectric::readDielectric(Ath__parser* parser)
{
  if (strcmp(""non_conformal_metal"", parser->get(0)) == 0) {
    strcpy(_non_conformal_metal, parser->get(1));
    _conformal = false;
    _trench    = false;
    return true;
  } else if (strcmp(""conformal"", parser->get(0)) == 0) {
    _conformal = true;
    return true;
  } else if (strcmp(""trench"", parser->get(0)) == 0) {
    _trench = true;
    return true;
  } else if (parser->setDoubleVal(""epsilon"", 1, _epsilon))
    return true;
  else if (parser->setDoubleVal(""distance"", 1, _distance))
    return true;
  else if (parser->setIntVal(""met"", 1, _met))
    return true;
  else if (parser->setIntVal(""next_met"", 1, _nextMet))
    return true;
  else if (parser->setDoubleVal(""height"", 1, _height))
    return true;
  else if (parser->setDoubleVal(""thickness"", 1, _thickness))
    return true;
  else if (parser->setDoubleVal(""bottom_thickness"", 1, _bottom_thickness))
    return true;
  else if (parser->setDoubleVal(""top_thickness"", 1, _top_thickness))
    return true;
  else if (parser->setDoubleVal(""left_thickness"", 1, _left_thickness))
    return true;
  else if (parser->setDoubleVal(""right_thickness"", 1, _right_thickness))
    return true;
  else if (parser->setDoubleVal(""bottom_ext"", 1, _bottom_ext))
    return true;
  else if (parser->setDoubleVal(""slope"", 1, _slope))
    return true;

  return false;
}
extMasterConductor::extMasterConductor(uint          condId,
                                       extConductor* cond,
                                       double        prevHeight)
{
  _condId = condId;

  // X coordinates

  double min_width = cond->_min_width;
  if (cond->_bottom_right_x - cond->_bottom_left_x > 0) {
    _loLeft[0]  = cond->_bottom_left_x;
    _loRight[0] = cond->_bottom_right_x;
  } else {
    if (cond->_bot_ext == 0.0)
      _loLeft[0] = 0;
    else
      _loLeft[0] = -cond->_bot_ext;
    if (!(min_width > 0)) {
      /*			fprintf(stdout, ""Cannot determine Bottom Width
         for Conductor <%s>\\n"", cond->_name);
      */
      odb::warning(
          0, ""Cannot determine Bottom Width for Conductor <%s>\\n"", cond->_name);
      exit(0);
    }
    if (cond->_bot_ext == 0.0)
      _loRight[0] = min_width;
    else
      _loRight[0] = min_width + cond->_bot_ext;
  }
  _hiLeft[0]  = cond->_top_left_x;
  _hiRight[0] = cond->_top_right_x;

  if (cond->_top_right_x - cond->_top_left_x > 0) {
    _hiLeft[0]  = cond->_top_left_x;
    _hiRight[0] = cond->_top_right_x;
  } else {
    if (cond->_top_ext == 0.0)
      _hiLeft[0] = 0;
    else
      _hiLeft[0] = -cond->_top_ext;
    if (!(min_width > 0)) {
      /*			fprintf(stdout, ""Cannot determine Top Width for
         Conductor <%s>\\n"", cond->_name);
      */
      odb::warning(
          0, ""Cannot determine Top Width for Conductor <%s>\\n"", cond->_name);
      exit(0);
    }
    if (cond->_top_ext == 0.0)
      _hiRight[0] = min_width;
    else
      _hiRight[0] = min_width + cond->_top_ext;
  }

  // Y coordinates
  _loLeft[1]  = 0;
  _loRight[1] = 0;
  _hiLeft[1]  = 0;
  _hiRight[1] = 0;

  // Z coordinates
  double height = cond->_height;
  if (height <= 0) {
    height += prevHeight + cond->_distance;
    cond->_height = height;
  }

  _loLeft[2]  = height;
  _loRight[2] = height;

  double thickness = cond->_thickness;
  if (!(thickness > 0)) {
    /*		fprintf(stdout, ""Cannot determine thickness for Conductor
       <%s>\\n"", cond->_name);
    */
    odb::warning(
        0, ""Cannot determine thickness for Conductor <%s>\\n"", cond->_name);
    exit(0);
  }
  _hiLeft[2]  = height + thickness;
  _hiRight[2] = height + thickness;

  _dy = 0;
  _e  = 0.0;
  for (uint i = 0; i < 3; i++)
    _conformalId[i] = 0;
}
void extMasterConductor::resetThicknessHeight(double height, double thickness)
{
  _hiLeft[2]  = height + thickness;
  _hiRight[2] = height + thickness;
  _loLeft[2]  = _hiLeft[2] - thickness;
  _loRight[2] = _loLeft[2];
}
void extMasterConductor::resetWidth(double top_width, double bottom_width)
{
  _loLeft[0]  = -bottom_width / 2;
  _loRight[0] = bottom_width / 2;

  _hiLeft[0]  = -top_width / 2;
  _hiRight[0] = top_width / 2;
}
void extMasterConductor::reset(double height,
                               double top_width,
                               double bottom_width,
                               double thickness)
{
  _loLeft[0]  = -bottom_width / 2;
  _loRight[0] = bottom_width / 2;

  _hiLeft[0]  = -top_width / 2;
  _hiRight[0] = top_width / 2;

  // Y coordinates
  _loLeft[1]  = 0;
  _loRight[1] = 0;
  _hiLeft[1]  = 0;
  _hiRight[1] = 0;

  // Z coordinates
  // assume target height and thickness were set

  _hiLeft[2]  = height + thickness;
  _hiRight[2] = height + thickness;
  _loLeft[2]  = _hiLeft[2] - thickness;
  _loRight[2] = _loLeft[2];

  //_hiLeft[2]= height + thickness;
  //_hiRight[2]= height + thickness;

  //_loLeft[2]= height;
  //_loRight[2]= height;
}
double extMasterConductor::writeRaphaelBox(FILE*  fp,
                                           uint   wireNum,
                                           double width,
                                           double X,
                                           double volt)
{
  return writeRaphaelPoly(fp, wireNum, width, X, volt);

  fprintf(fp, ""BOX NAME="");
  writeBoxName(fp, wireNum);

  fprintf(fp,
          "" CX=%g; CY=%g; W=%g; H=%g; VOLT=%g\\n"",
          X,
          _loLeft[2],
          width,
          _hiLeft[2] - _loLeft[2],
          volt);

  return X + width;
}
void extMasterConductor::writeRaphaelPointXY(FILE* fp, double X, double Y)
{
  fprintf(fp, ""  %6.3f,%6.3f ; "", X, Y);
}
void extProcess::writeRaphaelPointXY(FILE* fp, double X, double Y)
{
  fprintf(fp, ""  %6.3f,%6.3f ; "", X, Y);
}
void extMasterConductor::writeRaphaelPoly(FILE*  fp,
                                          uint   wireNum,
                                          double X,
                                          double volt)
{
  fprintf(fp, ""POLY NAME="");
  writeBoxName(fp, wireNum);

  fprintf(fp, "" COORD= "");

  writeRaphaelPointXY(fp, X + _loLeft[0], _loLeft[2]);
  writeRaphaelPointXY(fp, X + _loRight[0], _loLeft[2]);
  writeRaphaelPointXY(fp, X + _hiRight[0], _hiRight[2]);
  writeRaphaelPointXY(fp, X + _hiLeft[0], _hiLeft[2]);

  fprintf(fp, "" VOLT=%g\\n"", volt);
}
void extMasterConductor::writeRaphaelConformalPoly(FILE*       fp,
                                                   double      width,
                                                   double      X,
                                                   extProcess* p)
{
  double height[3];
  double thickness[3];
  double bottom_ext[3];
  double slope[3];
  double e[3];
  bool   trench = false;
  uint   cnt    = 0;
  uint   start  = 0;
  double h      = _loLeft[2];
  for (uint i = 0; i < 3; i++) {
    uint j = 2 - i;
    if (!_conformalId[j])
      continue;
    if (!start)
      start = i;
    extDielectric* d = p->getDielectric(_conformalId[j]);
    // assuming conformal and trench will not show up at the same time. Also
    // height for the trench layer is negative.
    trench        = d->_trench;
    height[i]     = d->_height;
    thickness[i]  = d->_thickness;
    bottom_ext[i] = d->_bottom_ext;
    slope[i]      = d->_slope;
    e[i]          = d->_epsilon;
    h += d->_thickness;
    cnt++;
  }
  if (!cnt)
    return;
  if (trench) {
    for (uint j = start; j < start + cnt; j++) {
      fprintf(fp, ""POLY NAME="");
      fprintf(fp, ""M%d_Trench%d;"", _condId, 2 - j);
      if (width == 0.0) {
        writeRaphaelPointXY(
            fp, X + _loLeft[0] - bottom_ext[j], _hiRight[2] + height[j]);
        writeRaphaelPointXY(
            fp, X + _loRight[0] + bottom_ext[j], _hiRight[2] + height[j]);
        writeRaphaelPointXY(fp, X + _hiRight[0] + bottom_ext[j], _hiRight[2]);
        writeRaphaelPointXY(fp, X + _hiLeft[0] - bottom_ext[j], _hiRight[2]);
        fprintf(fp, "" DIEL=%g\\n"", e[j]);
      } else {
        writeRaphaelPointXY(fp, X - bottom_ext[j], _hiRight[2] + height[j]);
        writeRaphaelPointXY(
            fp, X + width + bottom_ext[j], _hiRight[2] + height[j]);
        writeRaphaelPointXY(fp, X + width + bottom_ext[j], _hiRight[2]);
        writeRaphaelPointXY(fp, X - bottom_ext[j], _hiRight[2]);
        fprintf(fp, "" DIEL=%g\\n"", e[j]);
      }
    }
    return;
  }
  double dx;
  for (uint j = start; j < start + cnt; j++) {
    fprintf(fp, ""POLY NAME="");
    fprintf(fp, ""M%d_Conformal%d;"", _condId, 2 - j);
    if (width == 0.0) {
      if (slope[j])
        dx = (height[j] - thickness[j]) / slope[j];
      else
        dx = bottom_ext[j];
      writeRaphaelPointXY(fp, X + _loLeft[0] - bottom_ext[j], h);
      writeRaphaelPointXY(fp, X + _loRight[0] + bottom_ext[j], h);
      h -= thickness[j];
      writeRaphaelPointXY(
          fp, X + _hiRight[0] + bottom_ext[j] - dx, h + height[j]);
      writeRaphaelPointXY(
          fp, X + _hiLeft[0] - bottom_ext[j] + dx, h + height[j]);
      fprintf(fp, "" DIEL=%g\\n"", e[j]);
    } else {
      if (slope[j])
        dx = (height[j] - thickness[j]) / slope[j];
      else
        dx = bottom_ext[j];
      writeRaphaelPointXY(fp, X - bottom_ext[j], h);
      writeRaphaelPointXY(fp, X + width + bottom_ext[j], h);
      h -= thickness[j];
      writeRaphaelPointXY(fp, X + width + bottom_ext[j] - dx, h + height[j]);
      writeRaphaelPointXY(fp, X - bottom_ext[j] + dx, h + height[j]);
      fprintf(fp, "" DIEL=%g\\n"", e[j]);
    }
  }
}
void extMasterConductor::writeRaphaelConformalGround(FILE*       fp,
                                                     double      X,
                                                     double      width,
                                                     extProcess* p)
{
  double height[3];
  double thickness[3];
  double bottom_ext[3];
  double slope[3];
  double e[3];
  bool   trench = false;
  uint   cnt    = 0;
  uint   start  = 0;
  double h      = _loLeft[2];
  for (uint i = 0; i < 3; i++) {
    uint j = 2 - i;
    if (!_conformalId[j])
      continue;
    if (!start)
      start = i;
    extDielectric* d = p->getDielectric(_conformalId[j]);
    // assuming conformal and trench will not show up at the same time. Also
    // height for the trench layer is negative.
    trench        = d->_trench;
    height[i]     = d->_height;
    thickness[i]  = d->_thickness;
    bottom_ext[i] = d->_bottom_ext;
    slope[i]      = d->_slope;
    e[i]          = d->_epsilon;
    h += d->_thickness;
    cnt++;
  }
  if (!cnt)
    return;
  if (trench) {
    for (uint j = start; j < start + cnt; j++) {
      fprintf(fp, ""POLY NAME="");
      fprintf(fp, ""M%d_Trench%d;"", _condId, 2 - j);

      writeRaphaelPointXY(fp, X, _hiRight[2] + height[j]);
      writeRaphaelPointXY(fp, X + width, _hiRight[2] + height[j]);
      writeRaphaelPointXY(fp, X + width, _hiRight[2]);
      writeRaphaelPointXY(fp, X, _hiRight[2]);
      fprintf(fp, "" DIEL=%g\\n"", e[j]);
    }
    return;
  }
  for (uint j = start; j < start + cnt; j++) {
    fprintf(fp, ""POLY NAME="");
    fprintf(fp, ""M%d_Conformal%d;"", _condId, 2 - j);

    h -= thickness[j];
    writeRaphaelPointXY(fp, X, h);
    writeRaphaelPointXY(fp, X + width, h);
    writeRaphaelPointXY(fp, X + width, h + height[j]);
    writeRaphaelPointXY(fp, X, h + height[j]);
    fprintf(fp, "" DIEL=%g\\n"", e[j]);
  }
}
void extMasterConductor::writeRaphaelPoly3D(FILE*  fp,
                                            uint   wireNum,
                                            double X,
                                            double length,
                                            double volt)
{
  fprintf(fp, ""POLY3D NAME="");
  writeBoxName(fp, wireNum);

  fprintf(fp, "" COORD= "");

  writeRaphaelPointXY(fp, X + _loLeft[0], _loLeft[2]);
  writeRaphaelPointXY(fp, X + _loRight[0], _loLeft[2]);
  writeRaphaelPointXY(fp, X + _hiRight[0], _hiRight[2]);
  writeRaphaelPointXY(fp, X + _hiLeft[0], _hiLeft[2]);

  fprintf(fp, ""V1=0,0,0; HEIGHT=%g;"", length);

  fprintf(fp, "" VOLT=%g\\n"", volt);
}
double extMasterConductor::writeRaphaelPoly(FILE*       fp,
                                            uint        wireNum,
                                            double      width,
                                            double      X,
                                            double      volt,
                                            extProcess* p)
{
  fprintf(fp, ""POLY NAME="");
  writeBoxName(fp, wireNum);

  fprintf(fp, "" COORD= "");

  extConductor* cond    = p->getConductor(_condId);
  double        top_ext = cond->_top_ext;
  double        bot_ext = cond->_bot_ext;

  writeRaphaelPointXY(fp, X - bot_ext, _loLeft[2]);
  writeRaphaelPointXY(fp, X + width + bot_ext, _loLeft[2]);
  writeRaphaelPointXY(fp, X + width + top_ext, _hiRight[2]);
  writeRaphaelPointXY(fp, X - top_ext, _hiLeft[2]);

  fprintf(fp, "" VOLT=%g\\n"", volt);
  return X + width;
}
double extMasterConductor::writeRaphaelPoly3D(FILE*  fp,
                                              uint   wireNum,
                                              double width,
                                              double length,
                                              double X,
                                              double volt)
{
  fprintf(fp, ""POLY3D NAME="");
  writeBoxName(fp, wireNum);

  fprintf(fp, "" COORD= "");

  writeRaphaelPointXY(fp, X, _loLeft[2]);
  writeRaphaelPointXY(fp, X + width, _loLeft[2]);
  writeRaphaelPointXY(fp, X + width, _hiRight[2]);
  writeRaphaelPointXY(fp, X, _hiLeft[2]);

  fprintf(fp, "" V1=0,0,0; HEIGHT=%g;"", length);
  fprintf(fp, "" VOLT=%g\\n"", volt);
  return X + width;
}
void extMasterConductor::writeBoxName(FILE* fp, uint wireNum)
{
  fprintf(fp, ""M%d_w%d;"", _condId, wireNum);
}
extMasterConductor::extMasterConductor(uint           dielId,
                                       extDielectric* diel,
                                       double         xlo,
                                       double         dx1,
                                       double         xhi,
                                       double         dx2,
                                       double         h,
                                       double         th)
{
  _condId = dielId;

  // X coordinates
  _loLeft[0]  = xlo;
  _loRight[0] = xlo + dx1;
  _hiLeft[0]  = xhi;
  _hiRight[0] = xhi + dx2;

  // Y coordinates
  _loLeft[1]  = 0;
  _loRight[1] = 0;
  _hiLeft[1]  = 0;
  _hiRight[1] = 0;

  // Z coordinates

  _loLeft[2]  = h;
  _loRight[2] = h;

  if (!(th > 0)) {
    /*		fprintf(stdout, ""Cannot determine thickness for Diel <%s>\\n"",
                            diel->_name);
    */
    odb::warning(0, ""Cannot determine thickness for Diel <%s>\\n"", diel->_name);
    //		exit(0);
  }
  _hiLeft[2]  = h + th;
  _hiRight[2] = h + th;

  _dy = 0;
  _e  = diel->_epsilon;
  for (uint i = 0; i < 3; i++)
    _conformalId[i] = 0;
}
FILE* extProcess::openFile(const char* filename, const char* permissions)
{
  FILE* fp = fopen(filename, permissions);
  if (fp == NULL) {
    //		fprintf(stdout, ""cannot open file %s with permissions <%s>\\n"",
    //			filename, permissions);
    odb::warning(0,
                 ""cannot open file %s with permissions <%s>\\n"",
                 filename,
                 permissions);
    exit(0);
  }
  return fp;
}
double extProcess::adjustMasterLayersForHeight(uint met, double thickness)
{
  double condThickness = _condTable->get(met)->_thickness;
  double dth           = (thickness - condThickness) / condThickness;

  double h = 0.0;
  for (uint ii = 1; ii < _masterConductorTable->getCnt(); ii++) {
    extConductor*       cond = _condTable->get(ii);
    extMasterConductor* m    = _masterConductorTable->get(ii);

    if (_thickVarFlag)
      h += cond->_distance * (1 + dth);
    else
      h += cond->_distance;

    double th = cond->_thickness;
    if (_thickVarFlag)
      th *= (1 + dth);
    else if (ii == met)
      th = thickness;

    m->resetThicknessHeight(h, th);
    h += th;
  }
  return dth;
}
double extProcess::adjustMasterDielectricsForHeight(uint met, double dth)
{
  double h = 0.0;
  for (uint ii = 1; ii < _masterDielectricTable->getCnt(); ii++) {
    extDielectric*      diel = _dielTable->get(ii);
    extMasterConductor* m    = _masterDielectricTable->get(ii);

    double th = diel->_thickness;
    if (_thickVarFlag)
      th *= (1 + dth);
    else if (diel->_met == (int) met)
      th *= (1 + dth);

    m->resetThicknessHeight(h, th);
    h += th;
  }
  return h;
}
void extProcess::createMasterLayers()
{
  double upperCondHeight = 0;
  for (uint ii = 1; ii < _condTable->getCnt(); ii++) {
    extConductor*       cond = _condTable->get(ii);
    extMasterConductor* m = new extMasterConductor(ii, cond, upperCondHeight);
    _masterConductorTable->add(m);
    upperCondHeight = cond->_height + cond->_thickness;
  }
  double h = 0.0;
  for (uint jj = 1; jj < _dielTable->getCnt(); jj++) {
    extDielectric* diel = _dielTable->get(jj);
    if ((diel->_conformal || diel->_trench) && diel->_met) {
      extMasterConductor* mm = _masterConductorTable->get(diel->_met);
      for (uint i = 0; i < 3; i++) {
        if (!mm->_conformalId[i]) {
          mm->_conformalId[i] = jj;
          break;
        }
      }
    }

    //		if (diel->_conformal) {
    extMasterConductor* m
        = new extMasterConductor(jj, diel, 0, 0, 0, 0, h, diel->_thickness);
    h += diel->_thickness;

    _masterDielectricTable->add(m);
    /*		}
                    else {
                            extMasterConductor *m=
                                    new extMasterConductor(jj, diel, 0, 0, 0, 0,
       0, 0);

                            _masterDielectricTable->add(m);
                    }
    */
  }
}
extConductor* extProcess::getConductor(uint ii)
{
  return _condTable->get(ii);
}
extMasterConductor* extProcess::getMasterConductor(uint ii)
{
  return _masterConductorTable->get(ii);
}
extDielectric* extProcess::getDielectric(uint ii)
{
  return _dielTable->get(ii);
}
Ath__array1D<double>* extProcess::getWidthTable(uint met)
{
  double min_width = getConductor(met)->_min_width;

  //	const double wTable[7]= {1.0, 1.5, 2.0, 2.5, 3, 3.5, 4};
  // const double wTable[3]= {1.0, 1.5, 2.0 };
  const double wTable[8] = {1.0, 1.5, 2.0, 2.5, 3, 4, 5, 10};

  //	Ath__array1D<double>* A= new Ath__array1D<double>(8);
  Ath__array1D<double>* A = new Ath__array1D<double>(11);
  //	for (uint ii= 0; ii<7; ii++) {
  // for (uint ii= 0; ii<3; ii++) {
  for (uint ii = 0; ii < 8; ii++) {
    double w = wTable[ii] * min_width;
    A->add(w);
  }

  return A;
}
Ath__array1D<double>* extProcess::getSpaceTable(uint met)
{
  double min_spacing = getConductor(met)->_min_spacing;

  //	const double sTable[18]= {1.0, 1.2, 1.5, 1.7, 2.0, 2.25, 2.5, 2.75,
  // 3, 3.5, 4, 4.5, 5, 6, 7, 8, 9, 10};
  const double sTable[8] = {1.0, 1.5, 2.0, 2.5, 3, 4, 5, 10};
  // const double sTable[3]= {1.0, 1.5, 2.0};

  Ath__array1D<double>* A = new Ath__array1D<double>(8);
  for (uint ii = 0; ii < 8; ii++) {
    // for (uint ii= 0; ii<3; ii++) {

    double s = sTable[ii] * min_spacing;
    A->add(s);
  }

  return A;
}
Ath__array1D<double>* extProcess::getDiagSpaceTable(uint met)
{
  double min_spacing = getConductor(met)->_min_spacing;
  double min_width   = getConductor(met)->_min_width;
  double p           = min_spacing + min_width;

  const double sTable[7] = {0, 0.2, 0.5, 0.7, 1.0, 2.0, 3};
  //	const double sTable[3]= {0, 0.5, 1.0};

  Ath__array1D<double>* A = new Ath__array1D<double>(8);
  for (uint ii = 0; ii < 7; ii++) {
    //	for (uint ii= 0; ii<3; ii++) {

    double s = sTable[ii] * p;
    A->add(s);
  }

  return A;
}
Ath__array1D<double>* extProcess::getDataRateTable(uint met)
{
  if (_dataRateTable)
    return _dataRateTable;
  Ath__array1D<double>* A = new Ath__array1D<double>(8);
  A->add(0.0);
  return A;
}
void extProcess::readDataRateTable(Ath__parser* parser, const char* keyword)
{
  if ((keyword != NULL) && (strcmp(keyword, parser->get(0)) != 0))
    return;

  if (parser->getWordCnt() < 1)
    return;
  Ath__array1D<double>* A = new Ath__array1D<double>(parser->getWordCnt() + 1);
  A->add(0.0);
  parser->getDoubleArray(A, 1);
  _dataRateTable = A;
  _thickVarFlag  = true;
}
bool extProcess::getMaxMinFlag()
{
  return _maxMinFlag;
}
bool extProcess::getThickVarFlag()
{
  return _thickVarFlag;
}
extMasterConductor* extProcess::getMasterConductor(uint    met,
                                                   uint    wIndex,
                                                   uint    sIndex,
                                                   double& w,
                                                   double& s)
{
  const double wTable[7] = {1.0, 1.5, 2.0, 2.5, 3, 3.5, 4};
  const double sTable[14]
      = {1.0, 1.2, 1.5, 1.7, 2.0, 2.25, 2.5, 2.75, 3, 3.5, 4, 4.5, 5, 6};

  extMasterConductor* m = getMasterConductor(met);

  w = wTable[wIndex] * getConductor(met)->_min_width;
  s = sTable[sIndex] * getConductor(met)->_min_spacing;

  return m;
}
extVariation* extProcess::getVariation(uint met)
{
  extConductor* m = getConductor(met);

  extVariation* v = NULL;
  if (m->_var_table_index > 0)
    v = _varTable->get(m->_var_table_index);

  return v;
}
double extVariation::interpolate(double                w,
                                 Ath__array1D<double>* X,
                                 Ath__array1D<double>* Y)
{
  if (X->getCnt() < 2)
    return w;

  int jj = X->findNextBiggestIndex(w);

  if (jj >= (int) X->getCnt() - 1)
    jj = X->getCnt() - 2;
  else if (jj < 0)
    jj = 0;

  double w1 = X->get(jj);
  double w2 = X->get(jj + 1);

  double v1 = Y->get(jj);
  double v2 = Y->get(jj + 1);

  double slope = (v2 - v1) / (w2 - w1);

  double retVal = v2 - slope * (w2 - w);

  return retVal;
}
double extVariation::getThickness(double w, uint dIndex)
{
  return interpolate(w, _thicknessC->_width, _thicknessC->_vTable[dIndex]);
}
double extVariation::getThicknessR(double w, uint dIndex)
{
  return interpolate(w, _thicknessR->_width, _thicknessR->_vTable[dIndex]);
}
double extVariation::getBottomWidth(double w, uint dIndex)
{
  return interpolate(w, _loWidthC->_width, _loWidthC->_vTable[dIndex]);
}
double extVariation::getBottomWidthR(double w, uint dIndex)
{
  return interpolate(w, _loWidthR->_width, _loWidthR->_vTable[dIndex]);
}
double extVariation::getTopWidth(uint ii, uint jj)
{
  return _hiWidthC->getVal(ii, jj);
}
double extVariation::getTopWidthR(uint ii, uint jj)
{
  return _hiWidthR->getVal(ii, jj);
}
Ath__array1D<double>* extVariation::getWidthTable()
{
  return _hiWidthC->_width;
}
Ath__array1D<double>* extVariation::getSpaceTable()
{
  return _hiWidthC->_space;
}
Ath__array1D<double>* extVariation::getDataRateTable()
{
  return _loWidthC->_density;
}
Ath__array1D<double>* extVariation::getPTable()
{
  if (_p == NULL)
    return NULL;
  return _p->_p;
}
double extVariation::getP(double w)
{
  if (_p == NULL)
    return 0;
  return interpolate(w, _p->_width, _p->_p);
}
void extProcess::writeProcess(const char* filename)
{
  FILE*       fp = openFile(filename, ""w"");
  Ath__parser parse;

  for (uint kk = 1; kk < _varTable->getCnt(); kk++) {
    _varTable->get(kk)->printVariation(fp, kk);
  }

  for (uint ii = 1; ii < _condTable->getCnt(); ii++) {
    extConductor* cond = _condTable->get(ii);
    cond->printConductor(fp, &parse);
  }
  for (uint jj = 1; jj < _dielTable->getCnt(); jj++) {
    extDielectric* diel = _dielTable->get(jj);
    diel->printDielectric(fp, &parse);
  }
  fclose(fp);
}
Ath__array1D<double>* extVarTable::readDoubleArray(Ath__parser* parser,
                                                   const char*  keyword)
{
  if ((keyword != NULL) && (strcmp(keyword, parser->get(0)) != 0))
    return NULL;

  if (parser->getWordCnt() < 1)
    return NULL;

  Ath__array1D<double>* A     = new Ath__array1D<double>(parser->getWordCnt());
  uint                  start = 0;
  if (keyword != NULL)
    start = 1;
  parser->getDoubleArray(A, start);
  return A;
}
void extVarTable::printOneLine(FILE*                 fp,
                               Ath__array1D<double>* A,
                               const char*           header,
                               const char*           trail)
{
  if (A == NULL)
    return;

  if (header != NULL)
    fprintf(fp, ""%s "", header);

  for (uint ii = 0; ii < A->getCnt(); ii++)
    fprintf(fp, ""%g "", A->get(ii));

  fprintf(fp, ""%s"", trail);
}
int extVarTable::readWidthSpacing2D(Ath__parser* parser,
                                    const char*  keyword1,
                                    const char*  keyword2,
                                    const char*  keyword3,
                                    const char*  key4)
{
  uint debug = 0;

  if (strcmp(""}"", parser->get(0)) == 0)
    return -1;
  _width = readDoubleArray(parser, keyword1);

  if (debug > 0)
    printOneLine(stdout, _width, keyword1, ""\\n"");

  if (!(parser->parseNextLine() > 0))
    return -1;

  if (strcmp(""Spacing"", keyword2) == 0) {
    _space = readDoubleArray(parser, keyword2);
  } else if (strcmp(""Deff"", keyword2) == 0) {
    _density = readDoubleArray(parser, keyword2);
    for (uint jj = 0; jj < _density->getCnt(); jj++)
      _vTable[jj] = new Ath__array1D<double>(_width->getCnt());
    if (debug > 0) {
      printOneLine(stdout, _space, keyword2, ""\\n"");
      printOneLine(stdout, _density, keyword2, ""\\n"");
    }
  } else if (strcmp(""P"", keyword2) == 0) {
    _p      = readDoubleArray(parser, keyword2);
    _rowCnt = 1;
    if (debug > 0)
      printOneLine(stdout, _p, keyword2, ""\\n"");
  }

  if (!(parser->parseNextLine() > 0))
    return -1;
  if (strcmp(""}"", keyword3) == 0) {
    return 1;
  } else if (strcmp(keyword3, parser->get(0)) != 0) {
    return -1;
  }

  uint ii = 0;
  while (parser->parseNextLine() > 0) {
    if (strcmp(key4, parser->get(0)) == 0) {
      break;
    }
    if (strcmp(""}"", parser->get(0)) == 0)
      break;
    if (_space != NULL) {
      _vTable[ii++] = readDoubleArray(parser, NULL);
      if (debug > 0)
        printOneLine(stdout, _vTable[ii - 1], NULL, ""\\n"");
    } else {
      ii++;
      for (int jj = 0; jj < parser->getWordCnt(); jj++)
        _vTable[jj]->add(parser->getDouble(jj));
    }
  }
  if (debug > 0) {
    if (_density != NULL) {
      for (uint jj = 0; jj < _density->getCnt(); jj++)
        printOneLine(stdout, _vTable[jj], NULL, ""\\n"");
    }
  }

  if (_space != NULL)
    _rowCnt = ii;
  else
    _rowCnt = _density->getCnt();

  return ii;
}
void extVarTable::printTable(FILE* fp, const char* valKey)
{
  printOneLine(fp, _width, ""Width"", ""\\n"");

  if (_space != NULL)
    printOneLine(fp, _space, ""Spacing"", ""\\n"");
  else if (_density != NULL)
    printOneLine(fp, _space, ""Deff"", ""\\n"");
  else {
    printOneLine(fp, _p, ""P"", ""\\n"");
    return;
  }

  fprintf(fp, ""%s\\n"", valKey);

  for (uint ii = 0; ii < _rowCnt; ii++)
    printOneLine(fp, _vTable[ii], NULL, ""\\n"");
}
void extVariation::printVariation(FILE* fp, uint n)
{
  fprintf(fp, ""VAR_TABLE %d {\\n"", n);

  _hiWidthC->printTable(fp, ""hi_cWidth_eff"");
  _loWidthC->printTable(fp, ""lo_cWidth_delta"");
  _thicknessC->printTable(fp, ""c_thickness_eff"");

  _hiWidthR->printTable(fp, ""hi_rWidth_eff"");
  _loWidthR->printTable(fp, ""lo_rWidth_delta"");
  _thicknessR->printTable(fp, ""r_thickness_eff"");
  if (_p != NULL)
    _p->printTable(fp, ""P"");

  fprintf(fp, ""}\\n"");
}
extVarTable* extVariation::readVarTable(Ath__parser* parser,
                                        const char*  key1,
                                        const char*  key2,
                                        const char*  key3,
                                        const char*  endKey)
{
  extVarTable* V = new extVarTable(20);  // TODO
  if (V->readWidthSpacing2D(parser, key1, key2, key3, endKey) < 1) {
    //		fprintf(stdout, ""Cannot read VarTable section: <%s>"", key3);
    odb::warning(0, ""Cannot read VarTable section: <%s>"", key3);
    delete V;
    return NULL;
  }

  return V;
}
int extVariation::readVariation(Ath__parser* parser)
{
  _hiWidthC
      = readVarTable(parser, ""Width"", ""Spacing"", ""hi_cWidth_eff"", ""Width"");
  _loWidthC = readVarTable(parser, ""Width"", ""Deff"", ""lo_cWidth_delta"", ""Width"");
  _thicknessC
      = readVarTable(parser, ""Width"", ""Deff"", ""c_thickness_eff"", ""Width"");

  _hiWidthR
      = readVarTable(parser, ""Width"", ""Spacing"", ""hi_rWidth_eff"", ""Width"");
  _loWidthR = readVarTable(parser, ""Width"", ""Deff"", ""lo_rWidth_delta"", ""Width"");
  _thicknessR
      = readVarTable(parser, ""Width"", ""Deff"", ""r_thickness_eff"", ""Width"");
  if (strcmp(""}"", parser->get(0)) == 0)
    return 0;
  _p = readVarTable(parser, ""Width"", ""P"", ""}"", """");

  return 0;
}
uint extProcess::readProcess(const char* name, char* filename)
{
  uint debug = 0;
  // create process object

  // read process numbers
  Ath__parser parser;
  parser.addSeparator(""\\r"");
  parser.openFile(filename);

  while (parser.parseNextLine() > 0) {
    if (strcmp(""PROCESS"", parser.get(0)) == 0) {
      while (parser.parseNextLine() > 0) {
        if (strcmp(""}"", parser.get(0)) == 0)
          break;
      }
    } else if (strcmp(""THICKNESS_VARIATION"", parser.get(0)) == 0) {
      readDataRateTable(&parser, ""THICKNESS_VARIATION"");
    } else if (strcmp(""VAR_TABLE"", parser.get(0)) == 0) {
      parser.setDbg(debug);
      parser.getInt(1);

      extVariation* extVar = new extVariation();

      while (parser.parseNextLine() > 0) {
        if (strcmp(""}"", parser.get(0)) == 0)
          break;
        extVar->readVariation(&parser);

        parser.setDbg(0);

        if (strcmp(""}"", parser.get(0)) == 0)
          break;
      }
      _varTable->add(extVar);
    } else if (strcmp(""CONDUCTOR"", parser.get(0)) == 0) {
      extConductor* cond = new extConductor();
      strcpy(cond->_name, parser.get(1));

      while (parser.parseNextLine() > 0) {
        if (strcmp(""}"", parser.get(0)) == 0)
          break;

        cond->readConductor(&parser);
      }
      _condTable->add(cond);
    } else if (strcmp(""DIELECTRIC"", parser.get(0)) == 0) {
      extDielectric* diel = new extDielectric();
      if (parser.getWordCnt() > 2)
        strcpy(diel->_name, parser.get(1));

      while (parser.parseNextLine() > 0) {
        if (strcmp(""}"", parser.get(0)) == 0)
          break;

        diel->readDielectric(&parser);
      }
      _dielTable->add(diel);
    } else if (strcmp(""SETMAXMINFLAG"", parser.get(0)) == 0) {
      _maxMinFlag = true;
    }
  }
  createMasterLayers();

  // create dielectric ""planes""

  //	uint layerCnt= 8;
  //	extRCModel *m= new extRCModel(layerCnt, (char *) name);
  //	_modelTable->add(m);

  return 0;
}
extProcess::extProcess(uint condCnt, uint dielCnt)
{
  _condTable = new Ath__array1D<extConductor*>(condCnt);
  _condTable->add(NULL);
  _maxMinFlag = false;
  _dielTable  = new Ath__array1D<extDielectric*>(dielCnt);
  _dielTable->add(NULL);
  _masterConductorTable = new Ath__array1D<extMasterConductor*>(condCnt);
  _masterConductorTable->add(NULL);
  _masterDielectricTable = new Ath__array1D<extMasterConductor*>(dielCnt);
  _masterDielectricTable->add(NULL);

  _varTable = new Ath__array1D<extVariation*>(condCnt);
  _varTable->add(NULL);
  _dataRateTable = NULL;
  _thickVarFlag  = false;
}
extVarTable::extVarTable(uint rowCnt)
{
  _rowCnt  = rowCnt;
  _vTable  = new Ath__array1D<double>*[rowCnt];
  _density = NULL;
  _space   = NULL;
  _width   = NULL;
  _p       = NULL;
}
extVarTable::~extVarTable()
{
  for (uint ii = 0; ii < _rowCnt; ii++) {
    if (_vTable[ii] != NULL)
      delete _vTable[ii];
  }
  delete[] _vTable;

  if (_density != NULL)
    delete _density;
  if (_space != NULL)
    delete _space;
  if (_width != NULL)
    delete _width;
  if (_p != NULL)
    delete _p;
  _p       = NULL;
  _density = NULL;
  _space   = NULL;
  _width   = NULL;
}

}  // namespace rcx
",16132,True,2705.044707443948,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.

#define RAPIDJSON_HAS_STDSTRING 1
#include ""flutter/shell/common/shell.h""

#include <memory>
#include <sstream>
#include <vector>

#include ""flutter/assets/directory_asset_bundle.h""
#include ""flutter/common/graphics/persistent_cache.h""
#include ""flutter/fml/base32.h""
#include ""flutter/fml/file.h""
#include ""flutter/fml/icu_util.h""
#include ""flutter/fml/log_settings.h""
#include ""flutter/fml/logging.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/fml/unique_fd.h""
#include ""flutter/runtime/dart_vm.h""
#include ""flutter/shell/common/engine.h""
#include ""flutter/shell/common/skia_event_tracer_impl.h""
#include ""flutter/shell/common/switches.h""
#include ""flutter/shell/common/vsync_waiter.h""
#include ""rapidjson/stringbuffer.h""
#include ""rapidjson/writer.h""
#include ""third_party/dart/runtime/include/dart_tools_api.h""
#include ""third_party/skia/include/core/SkGraphics.h""
#include ""third_party/skia/include/utils/SkBase64.h""
#include ""third_party/tonic/common/log.h""

namespace flutter {

constexpr char kSkiaChannel[] = ""flutter/skia"";
constexpr char kSystemChannel[] = ""flutter/system"";
constexpr char kTypeKey[] = ""type"";
constexpr char kFontChange[] = ""fontsChange"";

namespace {

std::unique_ptr<Engine> CreateEngine(
    Engine::Delegate& delegate,
    const PointerDataDispatcherMaker& dispatcher_maker,
    DartVM& vm,
    fml::RefPtr<const DartSnapshot> isolate_snapshot,
    TaskRunners task_runners,
    const PlatformData& platform_data,
    Settings settings,
    std::unique_ptr<Animator> animator,
    fml::WeakPtr<IOManager> io_manager,
    fml::RefPtr<SkiaUnrefQueue> unref_queue,
    fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
    std::shared_ptr<VolatilePathTracker> volatile_path_tracker) {
  return std::make_unique<Engine>(delegate,             //
                                  dispatcher_maker,     //
                                  vm,                   //
                                  isolate_snapshot,     //
                                  task_runners,         //
                                  platform_data,        //
                                  settings,             //
                                  std::move(animator),  //
                                  io_manager,           //
                                  unref_queue,          //
                                  snapshot_delegate,    //
                                  volatile_path_tracker);
}

// Though there can be multiple shells, some settings apply to all components in
// the process. These have to be set up before the shell or any of its
// sub-components can be initialized. In a perfect world, this would be empty.
// TODO(chinmaygarde): The unfortunate side effect of this call is that settings
// that cause shell initialization failures will still lead to some of their
// settings being applied.
void PerformInitializationTasks(Settings& settings) {
  {
    fml::LogSettings log_settings;
    log_settings.min_log_level =
        settings.verbose_logging ? fml::LOG_INFO : fml::LOG_ERROR;
    fml::SetLogSettings(log_settings);
  }

  static std::once_flag gShellSettingsInitialization = {};
  std::call_once(gShellSettingsInitialization, [&settings] {
    if (settings.engine_start_timestamp.count() == 0) {
      settings.engine_start_timestamp =
          std::chrono::microseconds(Dart_TimelineGetMicros());
    }

    tonic::SetLogHandler(
        [](const char* message) { FML_LOG(ERROR) << message; });

    if (settings.trace_skia) {
      InitSkiaEventTracer(settings.trace_skia, settings.trace_skia_allowlist);
    }

    if (!settings.trace_allowlist.empty()) {
      fml::tracing::TraceSetAllowlist(settings.trace_allowlist);
    }

    if (!settings.skia_deterministic_rendering_on_cpu) {
      SkGraphics::Init();
    } else {
      FML_DLOG(INFO) << ""Skia deterministic rendering is enabled."";
    }

    if (settings.icu_initialization_required) {
      if (settings.icu_data_path.size() != 0) {
        fml::icu::InitializeICU(settings.icu_data_path);
      } else if (settings.icu_mapper) {
        fml::icu::InitializeICUFromMapping(settings.icu_mapper());
      } else {
        FML_DLOG(WARNING) << ""Skipping ICU initialization in the shell."";
      }
    }
  });

  PersistentCache::SetCacheSkSL(settings.cache_sksl);
}

}  // namespace

std::unique_ptr<Shell> Shell::Create(
    const PlatformData& platform_data,
    TaskRunners task_runners,
    Settings settings,
    const Shell::CreateCallback<PlatformView>& on_create_platform_view,
    const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,
    bool is_gpu_disabled) {
  // This must come first as it initializes tracing.
  PerformInitializationTasks(settings);

  TRACE_EVENT0(""flutter"", ""Shell::Create"");

  // Always use the `vm_snapshot` and `isolate_snapshot` provided by the
  // settings to launch the VM.  If the VM is already running, the snapshot
  // arguments are ignored.
  auto vm_snapshot = DartSnapshot::VMSnapshotFromSettings(settings);
  auto isolate_snapshot = DartSnapshot::IsolateSnapshotFromSettings(settings);
  auto vm = DartVMRef::Create(settings, vm_snapshot, isolate_snapshot);
  FML_CHECK(vm) << ""Must be able to initialize the VM."";

  // If the settings did not specify an `isolate_snapshot`, fall back to the
  // one the VM was launched with.
  if (!isolate_snapshot) {
    isolate_snapshot = vm->GetVMData()->GetIsolateSnapshot();
  }
  return CreateWithSnapshot(std::move(platform_data),            //
                            std::move(task_runners),             //
                            /*parent_merger=*/nullptr,           //
                            std::move(settings),                 //
                            std::move(vm),                       //
                            std::move(isolate_snapshot),         //
                            std::move(on_create_platform_view),  //
                            std::move(on_create_rasterizer),     //
                            CreateEngine, is_gpu_disabled);
}

std::unique_ptr<Shell> Shell::CreateShellOnPlatformThread(
    DartVMRef vm,
    fml::RefPtr<fml::RasterThreadMerger> parent_merger,
    TaskRunners task_runners,
    const PlatformData& platform_data,
    Settings settings,
    fml::RefPtr<const DartSnapshot> isolate_snapshot,
    const Shell::CreateCallback<PlatformView>& on_create_platform_view,
    const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,
    const Shell::EngineCreateCallback& on_create_engine,
    bool is_gpu_disabled) {
  if (!task_runners.IsValid()) {
    FML_LOG(ERROR) << ""Task runners to run the shell were invalid."";
    return nullptr;
  }

  auto shell = std::unique_ptr<Shell>(
      new Shell(std::move(vm), task_runners, parent_merger, settings,
                std::make_shared<VolatilePathTracker>(
                    task_runners.GetUITaskRunner(),
                    !settings.skia_deterministic_rendering_on_cpu),
                is_gpu_disabled));

  // Create the rasterizer on the raster thread.
  std::promise<std::unique_ptr<Rasterizer>> rasterizer_promise;
  auto rasterizer_future = rasterizer_promise.get_future();
  std::promise<fml::WeakPtr<SnapshotDelegate>> snapshot_delegate_promise;
  auto snapshot_delegate_future = snapshot_delegate_promise.get_future();
  fml::TaskRunner::RunNowOrPostTask(
      task_runners.GetRasterTaskRunner(), [&rasterizer_promise,  //
                                           &snapshot_delegate_promise,
                                           on_create_rasterizer,  //
                                           shell = shell.get()    //
  ]() {
        TRACE_EVENT0(""flutter"", ""ShellSetupGPUSubsystem"");
        std::unique_ptr<Rasterizer> rasterizer(on_create_rasterizer(*shell));
        snapshot_delegate_promise.set_value(rasterizer->GetSnapshotDelegate());
        rasterizer_promise.set_value(std::move(rasterizer));
      });

  // Create the platform view on the platform thread (this thread).
  auto platform_view = on_create_platform_view(*shell.get());
  if (!platform_view || !platform_view->GetWeakPtr()) {
    return nullptr;
  }

  // Ask the platform view for the vsync waiter. This will be used by the engine
  // to create the animator.
  auto vsync_waiter = platform_view->CreateVSyncWaiter();
  if (!vsync_waiter) {
    return nullptr;
  }

  // Create the IO manager on the IO thread. The IO manager must be initialized
  // first because it has state that the other subsystems depend on. It must
  // first be booted and the necessary references obtained to initialize the
  // other subsystems.
  std::promise<std::unique_ptr<ShellIOManager>> io_manager_promise;
  auto io_manager_future = io_manager_promise.get_future();
  std::promise<fml::WeakPtr<ShellIOManager>> weak_io_manager_promise;
  auto weak_io_manager_future = weak_io_manager_promise.get_future();
  std::promise<fml::RefPtr<SkiaUnrefQueue>> unref_queue_promise;
  auto unref_queue_future = unref_queue_promise.get_future();
  auto io_task_runner = shell->GetTaskRunners().GetIOTaskRunner();

  // TODO(gw280): The WeakPtr here asserts that we are derefing it on the
  // same thread as it was created on. We are currently on the IO thread
  // inside this lambda but we need to deref the PlatformView, which was
  // constructed on the platform thread.
  //
  // https://github.com/flutter/flutter/issues/42948
  fml::TaskRunner::RunNowOrPostTask(
      io_task_runner,
      [&io_manager_promise,                                               //
       &weak_io_manager_promise,                                          //
       &unref_queue_promise,                                              //
       platform_view = platform_view->GetWeakPtr(),                       //
       io_task_runner,                                                    //
       is_backgrounded_sync_switch = shell->GetIsGpuDisabledSyncSwitch()  //
  ]() {
        TRACE_EVENT0(""flutter"", ""ShellSetupIOSubsystem"");
        auto io_manager = std::make_unique<ShellIOManager>(
            platform_view.getUnsafe()->CreateResourceContext(),
            is_backgrounded_sync_switch, io_task_runner);
        weak_io_manager_promise.set_value(io_manager->GetWeakPtr());
        unref_queue_promise.set_value(io_manager->GetSkiaUnrefQueue());
        io_manager_promise.set_value(std::move(io_manager));
      });

  // Send dispatcher_maker to the engine constructor because shell won't have
  // platform_view set until Shell::Setup is called later.
  auto dispatcher_maker = platform_view->GetDispatcherMaker();

  // Create the engine on the UI thread.
  std::promise<std::unique_ptr<Engine>> engine_promise;
  auto engine_future = engine_promise.get_future();
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetUITaskRunner(),
      fml::MakeCopyable([&engine_promise,                                 //
                         shell = shell.get(),                             //
                         &dispatcher_maker,                               //
                         &platform_data,                                  //
                         isolate_snapshot = std::move(isolate_snapshot),  //
                         vsync_waiter = std::move(vsync_waiter),          //
                         &weak_io_manager_future,                         //
                         &snapshot_delegate_future,                       //
                         &unref_queue_future,                             //
                         &on_create_engine]() mutable {
        TRACE_EVENT0(""flutter"", ""ShellSetupUISubsystem"");
        const auto& task_runners = shell->GetTaskRunners();

        // The animator is owned by the UI thread but it gets its vsync pulses
        // from the platform.
        auto animator = std::make_unique<Animator>(*shell, task_runners,
                                                   std::move(vsync_waiter));

        engine_promise.set_value(
            on_create_engine(*shell,                          //
                             dispatcher_maker,                //
                             *shell->GetDartVM(),             //
                             std::move(isolate_snapshot),     //
                             task_runners,                    //
                             platform_data,                   //
                             shell->GetSettings(),            //
                             std::move(animator),             //
                             weak_io_manager_future.get(),    //
                             unref_queue_future.get(),        //
                             snapshot_delegate_future.get(),  //
                             shell->volatile_path_tracker_));
      }));

  if (!shell->Setup(std::move(platform_view),  //
                    engine_future.get(),       //
                    rasterizer_future.get(),   //
                    io_manager_future.get())   //
  ) {
    return nullptr;
  }

  return shell;
}

std::unique_ptr<Shell> Shell::CreateWithSnapshot(
    const PlatformData& platform_data,
    TaskRunners task_runners,
    fml::RefPtr<fml::RasterThreadMerger> parent_thread_merger,
    Settings settings,
    DartVMRef vm,
    fml::RefPtr<const DartSnapshot> isolate_snapshot,
    const Shell::CreateCallback<PlatformView>& on_create_platform_view,
    const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,
    const Shell::EngineCreateCallback& on_create_engine,
    bool is_gpu_disabled) {
  // This must come first as it initializes tracing.
  PerformInitializationTasks(settings);

  TRACE_EVENT0(""flutter"", ""Shell::CreateWithSnapshot"");

  const bool callbacks_valid =
      on_create_platform_view && on_create_rasterizer && on_create_engine;
  if (!task_runners.IsValid() || !callbacks_valid) {
    return nullptr;
  }

  fml::AutoResetWaitableEvent latch;
  std::unique_ptr<Shell> shell;
  fml::TaskRunner::RunNowOrPostTask(
      task_runners.GetPlatformTaskRunner(),
      fml::MakeCopyable(
          [&latch,                                                        //
           &shell,                                                        //
           parent_thread_merger,                                          //
           task_runners = std::move(task_runners),                        //
           platform_data = std::move(platform_data),                      //
           settings = std::move(settings),                                //
           vm = std::move(vm),                                            //
           isolate_snapshot = std::move(isolate_snapshot),                //
           on_create_platform_view = std::move(on_create_platform_view),  //
           on_create_rasterizer = std::move(on_create_rasterizer),        //
           on_create_engine = std::move(on_create_engine),
           is_gpu_disabled]() mutable {
            shell = CreateShellOnPlatformThread(
                std::move(vm),                       //
                parent_thread_merger,                //
                std::move(task_runners),             //
                std::move(platform_data),            //
                std::move(settings),                 //
                std::move(isolate_snapshot),         //
                std::move(on_create_platform_view),  //
                std::move(on_create_rasterizer),     //
                std::move(on_create_engine), is_gpu_disabled);
            latch.Signal();
          }));
  latch.Wait();
  return shell;
}

Shell::Shell(DartVMRef vm,
             TaskRunners task_runners,
             fml::RefPtr<fml::RasterThreadMerger> parent_merger,
             Settings settings,
             std::shared_ptr<VolatilePathTracker> volatile_path_tracker,
             bool is_gpu_disabled)
    : task_runners_(std::move(task_runners)),
      parent_raster_thread_merger_(parent_merger),
      settings_(std::move(settings)),
      vm_(std::move(vm)),
      is_gpu_disabled_sync_switch_(new fml::SyncSwitch(is_gpu_disabled)),
      volatile_path_tracker_(std::move(volatile_path_tracker)),
      weak_factory_gpu_(nullptr),
      weak_factory_(this) {
  FML_CHECK(vm_) << ""Must have access to VM to create a shell."";
  FML_DCHECK(task_runners_.IsValid());
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

  display_manager_ = std::make_unique<DisplayManager>();

  // Generate a WeakPtrFactory for use with the raster thread. This does not
  // need to wait on a latch because it can only ever be used from the raster
  // thread from this class, so we have ordering guarantees.
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetRasterTaskRunner(), fml::MakeCopyable([this]() mutable {
        this->weak_factory_gpu_ =
            std::make_unique<fml::TaskRunnerAffineWeakPtrFactory<Shell>>(this);
      }));

  // Install service protocol handlers.

  service_protocol_handlers_[ServiceProtocol::kScreenshotExtensionName] = {
      task_runners_.GetRasterTaskRunner(),
      std::bind(&Shell::OnServiceProtocolScreenshot, this,
                std::placeholders::_1, std::placeholders::_2)};
  service_protocol_handlers_[ServiceProtocol::kScreenshotSkpExtensionName] = {
      task_runners_.GetRasterTaskRunner(),
      std::bind(&Shell::OnServiceProtocolScreenshotSKP, this,
                std::placeholders::_1, std::placeholders::_2)};
  service_protocol_handlers_[ServiceProtocol::kRunInViewExtensionName] = {
      task_runners_.GetUITaskRunner(),
      std::bind(&Shell::OnServiceProtocolRunInView, this, std::placeholders::_1,
                std::placeholders::_2)};
  service_protocol_handlers_
      [ServiceProtocol::kFlushUIThreadTasksExtensionName] = {
          task_runners_.GetUITaskRunner(),
          std::bind(&Shell::OnServiceProtocolFlushUIThreadTasks, this,
                    std::placeholders::_1, std::placeholders::_2)};
  service_protocol_handlers_
      [ServiceProtocol::kSetAssetBundlePathExtensionName] = {
          task_runners_.GetUITaskRunner(),
          std::bind(&Shell::OnServiceProtocolSetAssetBundlePath, this,
                    std::placeholders::_1, std::placeholders::_2)};
  service_protocol_handlers_
      [ServiceProtocol::kGetDisplayRefreshRateExtensionName] = {
          task_runners_.GetUITaskRunner(),
          std::bind(&Shell::OnServiceProtocolGetDisplayRefreshRate, this,
                    std::placeholders::_1, std::placeholders::_2)};
  service_protocol_handlers_[ServiceProtocol::kGetSkSLsExtensionName] = {
      task_runners_.GetIOTaskRunner(),
      std::bind(&Shell::OnServiceProtocolGetSkSLs, this, std::placeholders::_1,
                std::placeholders::_2)};
  service_protocol_handlers_
      [ServiceProtocol::kEstimateRasterCacheMemoryExtensionName] = {
          task_runners_.GetRasterTaskRunner(),
          std::bind(&Shell::OnServiceProtocolEstimateRasterCacheMemory, this,
                    std::placeholders::_1, std::placeholders::_2)};
}

Shell::~Shell() {
  PersistentCache::GetCacheForProcess()->RemoveWorkerTaskRunner(
      task_runners_.GetIOTaskRunner());

  vm_->GetServiceProtocol()->RemoveHandler(this);

  fml::AutoResetWaitableEvent ui_latch, gpu_latch, platform_latch, io_latch;

  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetUITaskRunner(),
      fml::MakeCopyable([this, &ui_latch]() mutable {
        engine_.reset();
        ui_latch.Signal();
      }));
  ui_latch.Wait();

  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetRasterTaskRunner(),
      fml::MakeCopyable(
          [this, rasterizer = std::move(rasterizer_), &gpu_latch]() mutable {
            rasterizer.reset();
            this->weak_factory_gpu_.reset();
            gpu_latch.Signal();
          }));
  gpu_latch.Wait();

  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetIOTaskRunner(),
      fml::MakeCopyable([io_manager = std::move(io_manager_),
                         platform_view = platform_view_.get(),
                         &io_latch]() mutable {
        io_manager.reset();
        if (platform_view) {
          platform_view->ReleaseResourceContext();
        }
        io_latch.Signal();
      }));

  io_latch.Wait();

  // The platform view must go last because it may be holding onto platform side
  // counterparts to resources owned by subsystems running on other threads. For
  // example, the NSOpenGLContext on the Mac.
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetPlatformTaskRunner(),
      fml::MakeCopyable([platform_view = std::move(platform_view_),
                         &platform_latch]() mutable {
        platform_view.reset();
        platform_latch.Signal();
      }));
  platform_latch.Wait();
}

std::unique_ptr<Shell> Shell::Spawn(
    RunConfiguration run_configuration,
    const std::string& initial_route,
    const CreateCallback<PlatformView>& on_create_platform_view,
    const CreateCallback<Rasterizer>& on_create_rasterizer) const {
  FML_DCHECK(task_runners_.IsValid());
  // It's safe to store this value since it is set on the platform thread.
  bool is_gpu_disabled = false;
  GetIsGpuDisabledSyncSwitch()->Execute(
      fml::SyncSwitch::Handlers()
          .SetIfFalse([&is_gpu_disabled] { is_gpu_disabled = false; })
          .SetIfTrue([&is_gpu_disabled] { is_gpu_disabled = true; }));
  std::unique_ptr<Shell> result = (CreateWithSnapshot(
      PlatformData{}, task_runners_, rasterizer_->GetRasterThreadMerger(),
      GetSettings(), vm_, vm_->GetVMData()->GetIsolateSnapshot(),
      on_create_platform_view, on_create_rasterizer,
      [engine = this->engine_.get(), initial_route](
          Engine::Delegate& delegate,
          const PointerDataDispatcherMaker& dispatcher_maker, DartVM& vm,
          fml::RefPtr<const DartSnapshot> isolate_snapshot,
          TaskRunners task_runners, const PlatformData& platform_data,
          Settings settings, std::unique_ptr<Animator> animator,
          fml::WeakPtr<IOManager> io_manager,
          fml::RefPtr<SkiaUnrefQueue> unref_queue,
          fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
          std::shared_ptr<VolatilePathTracker> volatile_path_tracker) {
        return engine->Spawn(/*delegate=*/delegate,
                             /*dispatcher_maker=*/dispatcher_maker,
                             /*settings=*/settings,
                             /*animator=*/std::move(animator),
                             /*initial_route=*/initial_route);
      },
      is_gpu_disabled));
  result->shared_resource_context_ = io_manager_->GetSharedResourceContext();
  result->RunEngine(std::move(run_configuration));
  return result;
}

void Shell::NotifyLowMemoryWarning() const {
  auto trace_id = fml::tracing::TraceNonce();
  TRACE_EVENT_ASYNC_BEGIN0(""flutter"", ""Shell::NotifyLowMemoryWarning"",
                           trace_id);
  // This does not require a current isolate but does require a running VM.
  // Since a valid shell will not be returned to the embedder without a valid
  // DartVMRef, we can be certain that this is a safe spot to assume a VM is
  // running.
  ::Dart_NotifyLowMemory();

  task_runners_.GetRasterTaskRunner()->PostTask(
      [rasterizer = rasterizer_->GetWeakPtr(), trace_id = trace_id]() {
        if (rasterizer) {
          rasterizer->NotifyLowMemoryWarning();
        }
        TRACE_EVENT_ASYNC_END0(""flutter"", ""Shell::NotifyLowMemoryWarning"",
                               trace_id);
      });
  // The IO Manager uses resource cache limits of 0, so it is not necessary
  // to purge them.
}

void Shell::RunEngine(RunConfiguration run_configuration) {
  RunEngine(std::move(run_configuration), nullptr);
}

void Shell::RunEngine(
    RunConfiguration run_configuration,
    const std::function<void(Engine::RunStatus)>& result_callback) {
  auto result = [platform_runner = task_runners_.GetPlatformTaskRunner(),
                 result_callback](Engine::RunStatus run_result) {
    if (!result_callback) {
      return;
    }
    platform_runner->PostTask(
        [result_callback, run_result]() { result_callback(run_result); });
  };
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetUITaskRunner(),
      fml::MakeCopyable(
          [run_configuration = std::move(run_configuration),
           weak_engine = weak_engine_, result]() mutable {
            if (!weak_engine) {
              FML_LOG(ERROR)
                  << ""Could not launch engine with configuration - no engine."";
              result(Engine::RunStatus::Failure);
              return;
            }
            auto run_result = weak_engine->Run(std::move(run_configuration));
            if (run_result == flutter::Engine::RunStatus::Failure) {
              FML_LOG(ERROR) << ""Could not launch engine with configuration."";
            }
            result(run_result);
          }));
}

std::optional<DartErrorCode> Shell::GetUIIsolateLastError() const {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());

  if (!weak_engine_) {
    return std::nullopt;
  }
  switch (weak_engine_->GetUIIsolateLastError()) {
    case tonic::kCompilationErrorType:
      return DartErrorCode::CompilationError;
    case tonic::kApiErrorType:
      return DartErrorCode::ApiError;
    case tonic::kUnknownErrorType:
      return DartErrorCode::UnknownError;
    case tonic::kNoError:
      return DartErrorCode::NoError;
  }
  return DartErrorCode::UnknownError;
}

bool Shell::EngineHasLivePorts() const {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());

  if (!weak_engine_) {
    return false;
  }

  return weak_engine_->UIIsolateHasLivePorts();
}

bool Shell::IsSetup() const {
  return is_setup_;
}

bool Shell::Setup(std::unique_ptr<PlatformView> platform_view,
                  std::unique_ptr<Engine> engine,
                  std::unique_ptr<Rasterizer> rasterizer,
                  std::unique_ptr<ShellIOManager> io_manager) {
  if (is_setup_) {
    return false;
  }

  if (!platform_view || !engine || !rasterizer || !io_manager) {
    return false;
  }

  platform_view_ = std::move(platform_view);
  platform_message_handler_ = platform_view_->GetPlatformMessageHandler();
  engine_ = std::move(engine);
  rasterizer_ = std::move(rasterizer);
  io_manager_ = std::move(io_manager);

  // Set the external view embedder for the rasterizer.
  auto view_embedder = platform_view_->CreateExternalViewEmbedder();
  rasterizer_->SetExternalViewEmbedder(view_embedder);
  rasterizer_->SetSnapshotSurfaceProducer(
      platform_view_->CreateSnapshotSurfaceProducer());

  // The weak ptr must be generated in the platform thread which owns the unique
  // ptr.
  weak_engine_ = engine_->GetWeakPtr();
  weak_rasterizer_ = rasterizer_->GetWeakPtr();
  weak_platform_view_ = platform_view_->GetWeakPtr();

  // Setup the time-consuming default font manager right after engine created.
  if (!settings_.prefetched_default_font_manager) {
    fml::TaskRunner::RunNowOrPostTask(task_runners_.GetUITaskRunner(),
                                      [engine = weak_engine_] {
                                        if (engine) {
                                          engine->SetupDefaultFontManager();
                                        }
                                      });
  }

  is_setup_ = true;

  PersistentCache::GetCacheForProcess()->AddWorkerTaskRunner(
      task_runners_.GetIOTaskRunner());

  PersistentCache::GetCacheForProcess()->SetIsDumpingSkp(
      settings_.dump_skp_on_shader_compilation);

  if (settings_.purge_persistent_cache) {
    PersistentCache::GetCacheForProcess()->Purge();
  }

  return true;
}

const Settings& Shell::GetSettings() const {
  return settings_;
}

const TaskRunners& Shell::GetTaskRunners() const {
  return task_runners_;
}

const fml::RefPtr<fml::RasterThreadMerger> Shell::GetParentRasterThreadMerger()
    const {
  return parent_raster_thread_merger_;
}

fml::TaskRunnerAffineWeakPtr<Rasterizer> Shell::GetRasterizer() const {
  FML_DCHECK(is_setup_);
  return weak_rasterizer_;
}

fml::WeakPtr<Engine> Shell::GetEngine() {
  FML_DCHECK(is_setup_);
  return weak_engine_;
}

fml::WeakPtr<PlatformView> Shell::GetPlatformView() {
  FML_DCHECK(is_setup_);
  return weak_platform_view_;
}

fml::WeakPtr<ShellIOManager> Shell::GetIOManager() {
  FML_DCHECK(is_setup_);
  return io_manager_->GetWeakPtr();
}

DartVM* Shell::GetDartVM() {
  return &vm_;
}

// |PlatformView::Delegate|
void Shell::OnPlatformViewCreated(std::unique_ptr<Surface> surface) {
  TRACE_EVENT0(""flutter"", ""Shell::OnPlatformViewCreated"");
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

  // Prevent any request to change the thread configuration for raster and
  // platform queues while the platform view is being created.
  //
  // This prevents false positives such as this method starts assuming that the
  // raster and platform queues have a given thread configuration, but then the
  // configuration is changed by a task, and the assumption is no longer true.
  //
  // This incorrect assumption can lead to deadlock.
  // See `should_post_raster_task` for more.
  rasterizer_->DisableThreadMergerIfNeeded();

  // The normal flow executed by this method is that the platform thread is
  // starting the sequence and waiting on the latch. Later the UI thread posts
  // raster_task to the raster thread which signals the latch. If the raster and
  // the platform threads are the same this results in a deadlock as the
  // raster_task will never be posted to the platform/raster thread that is
  // blocked on a latch. To avoid the described deadlock, if the raster and the
  // platform threads are the same, should_post_raster_task will be false, and
  // then instead of posting a task to the raster thread, the ui thread just
  // signals the latch and the platform/raster thread follows with executing
  // raster_task.
  const bool should_post_raster_task =
      !task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread();

  fml::AutoResetWaitableEvent latch;
  auto raster_task =
      fml::MakeCopyable([&waiting_for_first_frame = waiting_for_first_frame_,
                         rasterizer = rasterizer_->GetWeakPtr(),  //
                         surface = std::move(surface)]() mutable {
        if (rasterizer) {
          // Enables the thread merger which may be used by the external view
          // embedder.
          rasterizer->EnableThreadMergerIfNeeded();
          rasterizer->Setup(std::move(surface));
        }

        waiting_for_first_frame.store(true);
      });

  // TODO(91717): This probably isn't necessary. The engine should be able to
  // handle things here via normal lifecycle messages.
  // https://github.com/flutter/flutter/issues/91717
  auto ui_task = [engine = engine_->GetWeakPtr()] {
    if (engine) {
      engine->OnOutputSurfaceCreated();
    }
  };

  // Threading: Capture platform view by raw pointer and not the weak pointer.
  // We are going to use the pointer on the IO thread which is not safe with a
  // weak pointer. However, we are preventing the platform view from being
  // collected by using a latch.
  auto* platform_view = platform_view_.get();

  FML_DCHECK(platform_view);

  auto io_task = [io_manager = io_manager_->GetWeakPtr(), platform_view,
                  ui_task_runner = task_runners_.GetUITaskRunner(), ui_task,
                  shared_resource_context = shared_resource_context_,
                  raster_task_runner = task_runners_.GetRasterTaskRunner(),
                  raster_task, should_post_raster_task, &latch] {
    if (io_manager && !io_manager->GetResourceContext()) {
      sk_sp<GrDirectContext> resource_context;
      if (shared_resource_context) {
        resource_context = shared_resource_context;
      } else {
        resource_context = platform_view->CreateResourceContext();
      }
      io_manager->NotifyResourceContextAvailable(resource_context);
    }
    // Step 1: Post a task on the UI thread to tell the engine that it has
    // an output surface.
    fml::TaskRunner::RunNowOrPostTask(ui_task_runner, ui_task);

    // Step 2: Tell the raster thread that it should create a surface for
    // its rasterizer.
    if (should_post_raster_task) {
      fml::TaskRunner::RunNowOrPostTask(raster_task_runner, raster_task);
    }
    latch.Signal();
  };

  fml::TaskRunner::RunNowOrPostTask(task_runners_.GetIOTaskRunner(), io_task);

  latch.Wait();
  if (!should_post_raster_task) {
    // See comment on should_post_raster_task, in this case the raster_task
    // wasn't executed, and we just run it here as the platform thread
    // is the raster thread.
    raster_task();
  }
}

// |PlatformView::Delegate|
void Shell::OnPlatformViewDestroyed() {
  TRACE_EVENT0(""flutter"", ""Shell::OnPlatformViewDestroyed"");
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

  // Prevent any request to change the thread configuration for raster and
  // platform queues while the platform view is being destroyed.
  //
  // This prevents false positives such as this method starts assuming that the
  // raster and platform queues have a given thread configuration, but then the
  // configuration is changed by a task, and the assumption is no longer true.
  //
  // This incorrect assumption can lead to deadlock.
  rasterizer_->DisableThreadMergerIfNeeded();

  // Note:
  // This is a synchronous operation because certain platforms depend on
  // setup/suspension of all activities that may be interacting with the GPU in
  // a synchronous fashion.
  // The UI thread does not need to be serialized here - there is sufficient
  // guardrailing in the rasterizer to allow the UI thread to post work to it
  // even after the surface has been torn down.

  fml::AutoResetWaitableEvent latch;

  auto io_task = [io_manager = io_manager_.get(), &latch]() {
    // Execute any pending Skia object deletions while GPU access is still
    // allowed.
    io_manager->GetIsGpuDisabledSyncSwitch()->Execute(
        fml::SyncSwitch::Handlers().SetIfFalse(
            [&] { io_manager->GetSkiaUnrefQueue()->Drain(); }));
    // Step 4: All done. Signal the latch that the platform thread is waiting
    // on.
    latch.Signal();
  };

  auto raster_task = [rasterizer = rasterizer_->GetWeakPtr(),
                      io_task_runner = task_runners_.GetIOTaskRunner(),
                      io_task]() {
    if (rasterizer) {
      // Enables the thread merger which is required prior tearing down the
      // rasterizer. If the raster and platform threads are merged, tearing down
      // the rasterizer unmerges the threads.
      rasterizer->EnableThreadMergerIfNeeded();
      rasterizer->Teardown();
    }
    // Step 3: Tell the IO thread to complete its remaining work.
    fml::TaskRunner::RunNowOrPostTask(io_task_runner, io_task);
  };

  // TODO(91717): This probably isn't necessary. The engine should be able to
  // handle things here via normal lifecycle messages.
  // https://github.com/flutter/flutter/issues/91717
  auto ui_task = [engine = engine_->GetWeakPtr()]() {
    if (engine) {
      engine->OnOutputSurfaceDestroyed();
    }
  };

  // Step 1: Post a task onto the UI thread to tell the engine that its output
  // surface is about to go away.
  fml::TaskRunner::RunNowOrPostTask(task_runners_.GetUITaskRunner(), ui_task);

  // Step 2: Post a task to the Raster thread (possibly this thread) to tell the
  // rasterizer the output surface is going away.
  fml::TaskRunner::RunNowOrPostTask(task_runners_.GetRasterTaskRunner(),
                                    raster_task);
  latch.Wait();
}

// |PlatformView::Delegate|
void Shell::OnPlatformViewSetViewportMetrics(const ViewportMetrics& metrics) {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

  if (metrics.device_pixel_ratio <= 0 || metrics.physical_width <= 0 ||
      metrics.physical_height <= 0) {
    FML_DLOG(ERROR)
        << ""Embedding reported invalid ViewportMetrics, ignoring update.""
        << ""\\nphysical_width: "" << metrics.physical_width
        << ""\\nphysical_height: "" << metrics.physical_height
        << ""\\ndevice_pixel_ratio: "" << metrics.device_pixel_ratio;
    return;
  }

  // This is the formula Android uses.
  // https://android.googlesource.com/platform/frameworks/base/+/master/libs/hwui/renderthread/CacheManager.cpp#41
  size_t max_bytes = metrics.physical_width * metrics.physical_height * 12 * 4;
  task_runners_.GetRasterTaskRunner()->PostTask(
      [rasterizer = rasterizer_->GetWeakPtr(), max_bytes] {
        if (rasterizer) {
          rasterizer->SetResourceCacheMaxBytes(max_bytes, false);
        }
      });

  task_runners_.GetUITaskRunner()->PostTask(
      [engine = engine_->GetWeakPtr(), metrics]() {
        if (engine) {
          engine->SetViewportMetrics(metrics);
        }
      });

  {
    std::scoped_lock<std::mutex> lock(resize_mutex_);
    expected_frame_size_ =
        SkISize::Make(metrics.physical_width, metrics.physical_height);
  }
}

// |PlatformView::Delegate|
void Shell::OnPlatformViewDispatchPlatformMessage(
    std::unique_ptr<PlatformMessage> message) {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

  task_runners_.GetUITaskRunner()->PostTask(fml::MakeCopyable(
      [engine = engine_->GetWeakPtr(), message = std::move(message)]() mutable {
        if (engine) {
          engine->DispatchPlatformMessage(std::move(message));
        }
      }));
}

// |PlatformView::Delegate|
void Shell::OnPlatformViewDispatchPointerDataPacket(
    std::unique_ptr<PointerDataPacket> packet) {
  TRACE_EVENT0(""flutter"", ""Shell::OnPlatformViewDispatchPointerDataPacket"");
  TRACE_FLOW_BEGIN(""flutter"", ""PointerEvent"", next_pointer_flow_id_);
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
  task_runners_.GetUITaskRunner()->PostTask(
      fml::MakeCopyable([engine = weak_engine_, packet = std::move(packet),
                         flow_id = next_pointer_flow_id_]() mutable {
        if (engine) {
          engine->DispatchPointerDataPacket(std::move(packet), flow_id);
        }
      }));
  next_pointer_flow_id_++;
}

// |PlatformView::Delegate|
void Shell::OnPlatformViewDispatchSemanticsAction(int32_t id,
                                                  SemanticsAction action,
                                                  fml::MallocMapping args) {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

  task_runners_.GetUITaskRunner()->PostTask(
      fml::MakeCopyable([engine = engine_->GetWeakPtr(), id, action,
                         args = std::move(args)]() mutable {
        if (engine) {
          engine->DispatchSemanticsAction(id, action, std::move(args));
        }
      }));
}

// |PlatformView::Delegate|
void Shell::OnPlatformViewSetSemanticsEnabled(bool enabled) {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

  task_runners_.GetUITaskRunner()->PostTask(
      [engine = engine_->GetWeakPtr(), enabled] {
        if (engine) {
          engine->SetSemanticsEnabled(enabled);
        }
      });
}

// |PlatformView::Delegate|
void Shell::OnPlatformViewSetAccessibilityFeatures(int32_t flags) {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

  task_runners_.GetUITaskRunner()->PostTask(
      [engine = engine_->GetWeakPtr(), flags] {
        if (engine) {
          engine->SetAccessibilityFeatures(flags);
        }
      });
}

// |PlatformView::Delegate|
void Shell::OnPlatformViewRegisterTexture(
    std::shared_ptr<flutter::Texture> texture) {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

  task_runners_.GetRasterTaskRunner()->PostTask(
      [rasterizer = rasterizer_->GetWeakPtr(), texture] {
        if (rasterizer) {
          if (auto* registry = rasterizer->GetTextureRegistry()) {
            registry->RegisterTexture(texture);
          }
        }
      });
}

// |PlatformView::Delegate|
void Shell::OnPlatformViewUnregisterTexture(int64_t texture_id) {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

  task_runners_.GetRasterTaskRunner()->PostTask(
      [rasterizer = rasterizer_->GetWeakPtr(), texture_id]() {
        if (rasterizer) {
          if (auto* registry = rasterizer->GetTextureRegistry()) {
            registry->UnregisterTexture(texture_id);
          }
        }
      });
}

// |PlatformView::Delegate|
void Shell::OnPlatformViewMarkTextureFrameAvailable(int64_t texture_id) {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

  // Tell the rasterizer that one of its textures has a new frame available.
  task_runners_.GetRasterTaskRunner()->PostTask(
      [rasterizer = rasterizer_->GetWeakPtr(), texture_id]() {
        auto* registry = rasterizer->GetTextureRegistry();

        if (!registry) {
          return;
        }

        auto texture = registry->GetTexture(texture_id);

        if (!texture) {
          return;
        }

        texture->MarkNewFrameAvailable();
      });

  // Schedule a new frame without having to rebuild the layer tree.
  task_runners_.GetUITaskRunner()->PostTask([engine = engine_->GetWeakPtr()]() {
    if (engine) {
      engine->ScheduleFrame(false);
    }
  });
}

// |PlatformView::Delegate|
void Shell::OnPlatformViewSetNextFrameCallback(const fml::closure& closure) {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

  task_runners_.GetRasterTaskRunner()->PostTask(
      [rasterizer = rasterizer_->GetWeakPtr(), closure = closure]() {
        if (rasterizer) {
          rasterizer->SetNextFrameCallback(std::move(closure));
        }
      });
}

// |Animator::Delegate|
void Shell::OnAnimatorBeginFrame(fml::TimePoint frame_target_time,
                                 uint64_t frame_number) {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());

  // record the target time for use by rasterizer.
  {
    std::scoped_lock time_recorder_lock(time_recorder_mutex_);
    latest_frame_target_time_.emplace(frame_target_time);
  }
  if (engine_) {
    engine_->BeginFrame(frame_target_time, frame_number);
  }
}

// |Animator::Delegate|
void Shell::OnAnimatorNotifyIdle(int64_t deadline) {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());

  if (engine_) {
    engine_->NotifyIdle(deadline);
    volatile_path_tracker_->OnFrame();
  }
}

// |Animator::Delegate|
void Shell::OnAnimatorDraw(
    std::shared_ptr<Pipeline<flutter::LayerTree>> pipeline,
    std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder) {
  FML_DCHECK(is_setup_);

  // record the target time for use by rasterizer.
  {
    std::scoped_lock time_recorder_lock(time_recorder_mutex_);
    const fml::TimePoint frame_target_time =
        frame_timings_recorder->GetVsyncTargetTime();
    if (!latest_frame_target_time_) {
      latest_frame_target_time_ = frame_target_time;
    } else if (latest_frame_target_time_ < frame_target_time) {
      latest_frame_target_time_ = frame_target_time;
    }
  }

  auto discard_callback = [this](flutter::LayerTree& tree) {
    std::scoped_lock<std::mutex> lock(resize_mutex_);
    return !expected_frame_size_.isEmpty() &&
           tree.frame_size() != expected_frame_size_;
  };

  task_runners_.GetRasterTaskRunner()->PostTask(fml::MakeCopyable(
      [&waiting_for_first_frame = waiting_for_first_frame_,
       &waiting_for_first_frame_condition = waiting_for_first_frame_condition_,
       rasterizer = rasterizer_->GetWeakPtr(),
       weak_pipeline = std::weak_ptr<Pipeline<LayerTree>>(pipeline),
       discard_callback = std::move(discard_callback),
       frame_timings_recorder = std::move(frame_timings_recorder)]() mutable {
        if (rasterizer) {
          std::shared_ptr<Pipeline<LayerTree>> pipeline = weak_pipeline.lock();
          if (pipeline) {
            rasterizer->Draw(std::move(frame_timings_recorder),
                             std::move(pipeline), std::move(discard_callback));
          }

          if (waiting_for_first_frame.load()) {
            waiting_for_first_frame.store(false);
            waiting_for_first_frame_condition.notify_all();
          }
        }
      }));
}

// |Animator::Delegate|
void Shell::OnAnimatorDrawLastLayerTree(
    std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder) {
  FML_DCHECK(is_setup_);

  auto task = fml::MakeCopyable(
      [rasterizer = rasterizer_->GetWeakPtr(),
       frame_timings_recorder = std::move(frame_timings_recorder)]() mutable {
        if (rasterizer) {
          rasterizer->DrawLastLayerTree(std::move(frame_timings_recorder));
        }
      });

  task_runners_.GetRasterTaskRunner()->PostTask(task);
}

// |Engine::Delegate|
void Shell::OnEngineUpdateSemantics(SemanticsNodeUpdates update,
                                    CustomAccessibilityActionUpdates actions) {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());

  task_runners_.GetPlatformTaskRunner()->PostTask(
      [view = platform_view_->GetWeakPtr(), update = std::move(update),
       actions = std::move(actions)] {
        if (view) {
          view->UpdateSemantics(std::move(update), std::move(actions));
        }
      });
}

// |Engine::Delegate|
void Shell::OnEngineHandlePlatformMessage(
    std::unique_ptr<PlatformMessage> message) {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());

  if (message->channel() == kSkiaChannel) {
    HandleEngineSkiaMessage(std::move(message));
    return;
  }

  if (platform_message_handler_) {
    platform_message_handler_->HandlePlatformMessage(std::move(message));
  } else {
    task_runners_.GetPlatformTaskRunner()->PostTask(
        fml::MakeCopyable([view = platform_view_->GetWeakPtr(),
                           message = std::move(message)]() mutable {
          if (view) {
            view->HandlePlatformMessage(std::move(message));
          }
        }));
  }
}

void Shell::HandleEngineSkiaMessage(std::unique_ptr<PlatformMessage> message) {
  const auto& data = message->data();

  rapidjson::Document document;
  document.Parse(reinterpret_cast<const char*>(data.GetMapping()),
                 data.GetSize());
  if (document.HasParseError() || !document.IsObject()) {
    return;
  }
  auto root = document.GetObject();
  auto method = root.FindMember(""method"");
  if (method->value != ""Skia.setResourceCacheMaxBytes"") {
    return;
  }
  auto args = root.FindMember(""args"");
  if (args == root.MemberEnd() || !args->value.IsInt()) {
    return;
  }

  task_runners_.GetRasterTaskRunner()->PostTask(
      [rasterizer = rasterizer_->GetWeakPtr(), max_bytes = args->value.GetInt(),
       response = std::move(message->response())] {
        if (rasterizer) {
          rasterizer->SetResourceCacheMaxBytes(static_cast<size_t>(max_bytes),
                                               true);
        }
        if (response) {
          // The framework side expects this to be valid json encoded as a list.
          // Return `[true]` to signal success.
          std::vector<uint8_t> data = {'[', 't', 'r', 'u', 'e', ']'};
          response->Complete(
              std::make_unique<fml::DataMapping>(std::move(data)));
        }
      });
}

// |Engine::Delegate|
void Shell::OnPreEngineRestart() {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());

  fml::AutoResetWaitableEvent latch;
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetPlatformTaskRunner(),
      [view = platform_view_->GetWeakPtr(), &latch]() {
        if (view) {
          view->OnPreEngineRestart();
        }
        latch.Signal();
      });
  // This is blocking as any embedded platform views has to be flushed before
  // we re-run the Dart code.
  latch.Wait();
}

// |Engine::Delegate|
void Shell::OnRootIsolateCreated() {
  if (is_added_to_service_protocol_) {
    return;
  }
  auto description = GetServiceProtocolDescription();
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetPlatformTaskRunner(),
      [self = weak_factory_.GetWeakPtr(),
       description = std::move(description)]() {
        if (self) {
          self->vm_->GetServiceProtocol()->AddHandler(self.get(), description);
        }
      });
  is_added_to_service_protocol_ = true;
}

// |Engine::Delegate|
void Shell::UpdateIsolateDescription(const std::string isolate_name,
                                     int64_t isolate_port) {
  Handler::Description description(isolate_port, isolate_name);
  vm_->GetServiceProtocol()->SetHandlerDescription(this, description);
}

void Shell::SetNeedsReportTimings(bool value) {
  needs_report_timings_ = value;
}

// |Engine::Delegate|
std::unique_ptr<std::vector<std::string>> Shell::ComputePlatformResolvedLocale(
    const std::vector<std::string>& supported_locale_data) {
  return platform_view_->ComputePlatformResolvedLocales(supported_locale_data);
}

void Shell::LoadDartDeferredLibrary(
    intptr_t loading_unit_id,
    std::unique_ptr<const fml::Mapping> snapshot_data,
    std::unique_ptr<const fml::Mapping> snapshot_instructions) {
  task_runners_.GetUITaskRunner()->PostTask(fml::MakeCopyable(
      [engine = engine_->GetWeakPtr(), loading_unit_id,
       data = std::move(snapshot_data),
       instructions = std::move(snapshot_instructions)]() mutable {
        if (engine) {
          engine->LoadDartDeferredLibrary(loading_unit_id, std::move(data),
                                          std::move(instructions));
        }
      }));
}

void Shell::LoadDartDeferredLibraryError(intptr_t loading_unit_id,
                                         const std::string error_message,
                                         bool transient) {
  engine_->LoadDartDeferredLibraryError(loading_unit_id, error_message,
                                        transient);
}

void Shell::UpdateAssetResolverByType(
    std::unique_ptr<AssetResolver> updated_asset_resolver,
    AssetResolver::AssetResolverType type) {
  engine_->GetAssetManager()->UpdateResolverByType(
      std::move(updated_asset_resolver), type);
}

// |Engine::Delegate|
void Shell::RequestDartDeferredLibrary(intptr_t loading_unit_id) {
  task_runners_.GetPlatformTaskRunner()->PostTask(
      [view = platform_view_->GetWeakPtr(), loading_unit_id] {
        if (view) {
          view->RequestDartDeferredLibrary(loading_unit_id);
        }
      });
}

void Shell::ReportTimings() {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());

  auto timings = std::move(unreported_timings_);
  unreported_timings_ = {};
  task_runners_.GetUITaskRunner()->PostTask([timings, engine = weak_engine_] {
    if (engine) {
      engine->ReportTimings(std::move(timings));
    }
  });
}

size_t Shell::UnreportedFramesCount() const {
  // Check that this is running on the raster thread to avoid race conditions.
  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
  FML_DCHECK(unreported_timings_.size() % (FrameTiming::kStatisticsCount) == 0);
  return unreported_timings_.size() / (FrameTiming::kStatisticsCount);
}

void Shell::OnFrameRasterized(const FrameTiming& timing) {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());

  // The C++ callback defined in settings.h and set by Flutter runner. This is
  // independent of the timings report to the Dart side.
  if (settings_.frame_rasterized_callback) {
    settings_.frame_rasterized_callback(timing);
  }

  if (!needs_report_timings_) {
    return;
  }

  size_t old_count = unreported_timings_.size();
  (void)old_count;
  for (auto phase : FrameTiming::kPhases) {
    unreported_timings_.push_back(
        timing.Get(phase).ToEpochDelta().ToMicroseconds());
  }
  unreported_timings_.push_back(timing.GetLayerCacheCount());
  unreported_timings_.push_back(timing.GetLayerCacheBytes());
  unreported_timings_.push_back(timing.GetPictureCacheCount());
  unreported_timings_.push_back(timing.GetPictureCacheBytes());
  unreported_timings_.push_back(timing.GetFrameNumber());
  FML_DCHECK(unreported_timings_.size() ==
             old_count + FrameTiming::kStatisticsCount);

  // In tests using iPhone 6S with profile mode, sending a batch of 1 frame or a
  // batch of 100 frames have roughly the same cost of less than 0.1ms. Sending
  // a batch of 500 frames costs about 0.2ms. The 1 second threshold usually
  // kicks in before we reaching the following 100 frames threshold. The 100
  // threshold here is mainly for unit tests (so we don't have to write a
  // 1-second unit test), and make sure that our vector won't grow too big with
  // future 120fps, 240fps, or 1000fps displays.
  //
  // In the profile/debug mode, the timings are used by development tools which
  // require a latency of no more than 100ms. Hence we lower that 1-second
  // threshold to 100ms because performance overhead isn't that critical in
  // those cases.
  if (!first_frame_rasterized_ || UnreportedFramesCount() >= 100) {
    first_frame_rasterized_ = true;
    ReportTimings();
  } else if (!frame_timings_report_scheduled_) {
#if FLUTTER_RELEASE
    constexpr int kBatchTimeInMilliseconds = 1000;
#else
    constexpr int kBatchTimeInMilliseconds = 100;
#endif

    // Also make sure that frame times get reported with a max latency of 1
    // second. Otherwise, the timings of last few frames of an animation may
    // never be reported until the next animation starts.
    frame_timings_report_scheduled_ = true;
    task_runners_.GetRasterTaskRunner()->PostDelayedTask(
        [self = weak_factory_gpu_->GetWeakPtr()]() {
          if (!self) {
            return;
          }
          self->frame_timings_report_scheduled_ = false;
          if (self->UnreportedFramesCount() > 0) {
            self->ReportTimings();
          }
        },
        fml::TimeDelta::FromMilliseconds(kBatchTimeInMilliseconds));
  }
}

fml::Milliseconds Shell::GetFrameBudget() {
  double display_refresh_rate = display_manager_->GetMainDisplayRefreshRate();
  if (display_refresh_rate > 0) {
    return fml::RefreshRateToFrameBudget(display_refresh_rate);
  } else {
    return fml::kDefaultFrameBudget;
  }
}

fml::TimePoint Shell::GetLatestFrameTargetTime() const {
  std::scoped_lock time_recorder_lock(time_recorder_mutex_);
  FML_CHECK(latest_frame_target_time_.has_value())
      << ""GetLatestFrameTargetTime called before OnAnimatorBeginFrame"";
  return latest_frame_target_time_.value();
}

// |ServiceProtocol::Handler|
fml::RefPtr<fml::TaskRunner> Shell::GetServiceProtocolHandlerTaskRunner(
    std::string_view method) const {
  FML_DCHECK(is_setup_);
  auto found = service_protocol_handlers_.find(method);
  if (found != service_protocol_handlers_.end()) {
    return found->second.first;
  }
  return task_runners_.GetUITaskRunner();
}

// |ServiceProtocol::Handler|
bool Shell::HandleServiceProtocolMessage(
    std::string_view method,  // one if the extension names specified above.
    const ServiceProtocolMap& params,
    rapidjson::Document* response) {
  auto found = service_protocol_handlers_.find(method);
  if (found != service_protocol_handlers_.end()) {
    return found->second.second(params, response);
  }
  return false;
}

// |ServiceProtocol::Handler|
ServiceProtocol::Handler::Description Shell::GetServiceProtocolDescription()
    const {
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());

  if (!weak_engine_) {
    return ServiceProtocol::Handler::Description();
  }

  return {
      weak_engine_->GetUIIsolateMainPort(),
      weak_engine_->GetUIIsolateName(),
  };
}

static void ServiceProtocolParameterError(rapidjson::Document* response,
                                          std::string error_details) {
  auto& allocator = response->GetAllocator();
  response->SetObject();
  const int64_t kInvalidParams = -32602;
  response->AddMember(""code"", kInvalidParams, allocator);
  response->AddMember(""message"", ""Invalid params"", allocator);
  {
    rapidjson::Value details(rapidjson::kObjectType);
    details.AddMember(""details"", error_details, allocator);
    response->AddMember(""data"", details, allocator);
  }
}

static void ServiceProtocolFailureError(rapidjson::Document* response,
                                        std::string message) {
  auto& allocator = response->GetAllocator();
  response->SetObject();
  const int64_t kJsonServerError = -32000;
  response->AddMember(""code"", kJsonServerError, allocator);
  response->AddMember(""message"", message, allocator);
}

// Service protocol handler
bool Shell::OnServiceProtocolScreenshot(
    const ServiceProtocol::Handler::ServiceProtocolMap& params,
    rapidjson::Document* response) {
  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
  auto screenshot = rasterizer_->ScreenshotLastLayerTree(
      Rasterizer::ScreenshotType::CompressedImage, true);
  if (screenshot.data) {
    response->SetObject();
    auto& allocator = response->GetAllocator();
    response->AddMember(""type"", ""Screenshot"", allocator);
    rapidjson::Value image;
    image.SetString(static_cast<const char*>(screenshot.data->data()),
                    screenshot.data->size(), allocator);
    response->AddMember(""screenshot"", image, allocator);
    return true;
  }
  ServiceProtocolFailureError(response, ""Could not capture image screenshot."");
  return false;
}

// Service protocol handler
bool Shell::OnServiceProtocolScreenshotSKP(
    const ServiceProtocol::Handler::ServiceProtocolMap& params,
    rapidjson::Document* response) {
  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
  auto screenshot = rasterizer_->ScreenshotLastLayerTree(
      Rasterizer::ScreenshotType::SkiaPicture, true);
  if (screenshot.data) {
    response->SetObject();
    auto& allocator = response->GetAllocator();
    response->AddMember(""type"", ""ScreenshotSkp"", allocator);
    rapidjson::Value skp;
    skp.SetString(static_cast<const char*>(screenshot.data->data()),
                  screenshot.data->size(), allocator);
    response->AddMember(""skp"", skp, allocator);
    return true;
  }
  ServiceProtocolFailureError(response, ""Could not capture SKP screenshot."");
  return false;
}

// Service protocol handler
bool Shell::OnServiceProtocolRunInView(
    const ServiceProtocol::Handler::ServiceProtocolMap& params,
    rapidjson::Document* response) {
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());

  if (params.count(""mainScript"") == 0) {
    ServiceProtocolParameterError(response,
                                  ""'mainScript' parameter is missing."");
    return false;
  }

  if (params.count(""assetDirectory"") == 0) {
    ServiceProtocolParameterError(response,
                                  ""'assetDirectory' parameter is missing."");
    return false;
  }

  std::string main_script_path =
      fml::paths::FromURI(params.at(""mainScript"").data());
  std::string asset_directory_path =
      fml::paths::FromURI(params.at(""assetDirectory"").data());

  auto main_script_file_mapping =
      std::make_unique<fml::FileMapping>(fml::OpenFile(
          main_script_path.c_str(), false, fml::FilePermission::kRead));

  auto isolate_configuration = IsolateConfiguration::CreateForKernel(
      std::move(main_script_file_mapping));

  RunConfiguration configuration(std::move(isolate_configuration));

  configuration.SetEntrypointAndLibrary(engine_->GetLastEntrypoint(),
                                        engine_->GetLastEntrypointLibrary());
  configuration.SetEntrypointArgs(engine_->GetLastEntrypointArgs());

  configuration.AddAssetResolver(std::make_unique<DirectoryAssetBundle>(
      fml::OpenDirectory(asset_directory_path.c_str(), false,
                         fml::FilePermission::kRead),
      false));

  // Preserve any original asset resolvers to avoid syncing unchanged assets
  // over the DevFS connection.
  auto old_asset_manager = engine_->GetAssetManager();
  if (old_asset_manager != nullptr) {
    for (auto& old_resolver : old_asset_manager->TakeResolvers()) {
      if (old_resolver->IsValidAfterAssetManagerChange()) {
        configuration.AddAssetResolver(std::move(old_resolver));
      }
    }
  }

  auto& allocator = response->GetAllocator();
  response->SetObject();
  if (engine_->Restart(std::move(configuration))) {
    response->AddMember(""type"", ""Success"", allocator);
    auto new_description = GetServiceProtocolDescription();
    rapidjson::Value view(rapidjson::kObjectType);
    new_description.Write(this, view, allocator);
    response->AddMember(""view"", view, allocator);
    return true;
  } else {
    FML_DLOG(ERROR) << ""Could not run configuration in engine."";
    ServiceProtocolFailureError(response,
                                ""Could not run configuration in engine."");
    return false;
  }

  FML_DCHECK(false);
  return false;
}

// Service protocol handler
bool Shell::OnServiceProtocolFlushUIThreadTasks(
    const ServiceProtocol::Handler::ServiceProtocolMap& params,
    rapidjson::Document* response) {
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());
  // This API should not be invoked by production code.
  // It can potentially starve the service isolate if the main isolate pauses
  // at a breakpoint or is in an infinite loop.
  //
  // It should be invoked from the VM Service and and blocks it until UI thread
  // tasks are processed.
  response->SetObject();
  response->AddMember(""type"", ""Success"", response->GetAllocator());
  return true;
}

bool Shell::OnServiceProtocolGetDisplayRefreshRate(
    const ServiceProtocol::Handler::ServiceProtocolMap& params,
    rapidjson::Document* response) {
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());
  response->SetObject();
  response->AddMember(""type"", ""DisplayRefreshRate"", response->GetAllocator());
  response->AddMember(""fps"", display_manager_->GetMainDisplayRefreshRate(),
                      response->GetAllocator());
  return true;
}

double Shell::GetMainDisplayRefreshRate() {
  return display_manager_->GetMainDisplayRefreshRate();
}

void Shell::RegisterImageDecoder(ImageGeneratorFactory factory,
                                 int32_t priority) {
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
  FML_DCHECK(is_setup_);

  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetUITaskRunner(),
      [engine = engine_->GetWeakPtr(), factory = std::move(factory),
       priority]() {
        if (engine) {
          engine->GetImageGeneratorRegistry()->AddFactory(factory, priority);
        }
      });
}

bool Shell::OnServiceProtocolGetSkSLs(
    const ServiceProtocol::Handler::ServiceProtocolMap& params,
    rapidjson::Document* response) {
  FML_DCHECK(task_runners_.GetIOTaskRunner()->RunsTasksOnCurrentThread());
  response->SetObject();
  response->AddMember(""type"", ""GetSkSLs"", response->GetAllocator());

  rapidjson::Value shaders_json(rapidjson::kObjectType);
  PersistentCache* persistent_cache = PersistentCache::GetCacheForProcess();
  std::vector<PersistentCache::SkSLCache> sksls = persistent_cache->LoadSkSLs();
  for (const auto& sksl : sksls) {
    size_t b64_size =
        SkBase64::Encode(sksl.value->data(), sksl.value->size(), nullptr);
    sk_sp<SkData> b64_data = SkData::MakeUninitialized(b64_size + 1);
    char* b64_char = static_cast<char*>(b64_data->writable_data());
    SkBase64::Encode(sksl.value->data(), sksl.value->size(), b64_char);
    b64_char[b64_size] = 0;  // make it null terminated for printing
    rapidjson::Value shader_value(b64_char, response->GetAllocator());
    std::string_view key_view(reinterpret_cast<const char*>(sksl.key->data()),
                              sksl.key->size());
    auto encode_result = fml::Base32Encode(key_view);
    if (!encode_result.first) {
      continue;
    }
    rapidjson::Value shader_key(encode_result.second, response->GetAllocator());
    shaders_json.AddMember(shader_key, shader_value, response->GetAllocator());
  }
  response->AddMember(""SkSLs"", shaders_json, response->GetAllocator());
  return true;
}

bool Shell::OnServiceProtocolEstimateRasterCacheMemory(
    const ServiceProtocol::Handler::ServiceProtocolMap& params,
    rapidjson::Document* response) {
  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
  const auto& raster_cache = rasterizer_->compositor_context()->raster_cache();
  response->SetObject();
  response->AddMember(""type"", ""EstimateRasterCacheMemory"",
                      response->GetAllocator());
  response->AddMember<uint64_t>(""layerBytes"",
                                raster_cache.EstimateLayerCacheByteSize(),
                                response->GetAllocator());
  response->AddMember<uint64_t>(""pictureBytes"",
                                raster_cache.EstimatePictureCacheByteSize(),
                                response->GetAllocator());
  return true;
}

// Service protocol handler
bool Shell::OnServiceProtocolSetAssetBundlePath(
    const ServiceProtocol::Handler::ServiceProtocolMap& params,
    rapidjson::Document* response) {
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());

  if (params.count(""assetDirectory"") == 0) {
    ServiceProtocolParameterError(response,
                                  ""'assetDirectory' parameter is missing."");
    return false;
  }

  auto& allocator = response->GetAllocator();
  response->SetObject();

  auto asset_manager = std::make_shared<AssetManager>();

  asset_manager->PushFront(std::make_unique<DirectoryAssetBundle>(
      fml::OpenDirectory(params.at(""assetDirectory"").data(), false,
                         fml::FilePermission::kRead),
      false));

  // Preserve any original asset resolvers to avoid syncing unchanged assets
  // over the DevFS connection.
  auto old_asset_manager = engine_->GetAssetManager();
  if (old_asset_manager != nullptr) {
    for (auto& old_resolver : old_asset_manager->TakeResolvers()) {
      if (old_resolver->IsValidAfterAssetManagerChange()) {
        asset_manager->PushBack(std::move(old_resolver));
      }
    }
  }

  if (engine_->UpdateAssetManager(std::move(asset_manager))) {
    response->AddMember(""type"", ""Success"", allocator);
    auto new_description = GetServiceProtocolDescription();
    rapidjson::Value view(rapidjson::kObjectType);
    new_description.Write(this, view, allocator);
    response->AddMember(""view"", view, allocator);
    return true;
  } else {
    FML_DLOG(ERROR) << ""Could not update asset directory."";
    ServiceProtocolFailureError(response, ""Could not update asset directory."");
    return false;
  }

  FML_DCHECK(false);
  return false;
}

Rasterizer::Screenshot Shell::Screenshot(
    Rasterizer::ScreenshotType screenshot_type,
    bool base64_encode) {
  TRACE_EVENT0(""flutter"", ""Shell::Screenshot"");
  fml::AutoResetWaitableEvent latch;
  Rasterizer::Screenshot screenshot;
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetRasterTaskRunner(), [&latch,                        //
                                            rasterizer = GetRasterizer(),  //
                                            &screenshot,                   //
                                            screenshot_type,               //
                                            base64_encode                  //
  ]() {
        if (rasterizer) {
          screenshot = rasterizer->ScreenshotLastLayerTree(screenshot_type,
                                                           base64_encode);
        }
        latch.Signal();
      });
  latch.Wait();
  return screenshot;
}

fml::Status Shell::WaitForFirstFrame(fml::TimeDelta timeout) {
  FML_DCHECK(is_setup_);
  if (task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread() ||
      task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread()) {
    return fml::Status(fml::StatusCode::kFailedPrecondition,
                       ""WaitForFirstFrame called from thread that can't wait ""
                       ""because it is responsible for generating the frame."");
  }

  // Check for overflow.
  auto now = std::chrono::steady_clock::now();
  auto max_duration = std::chrono::steady_clock::time_point::max() - now;
  auto desired_duration = std::chrono::milliseconds(timeout.ToMilliseconds());
  auto duration =
      now + (desired_duration > max_duration ? max_duration : desired_duration);

  std::unique_lock<std::mutex> lock(waiting_for_first_frame_mutex_);
  bool success = waiting_for_first_frame_condition_.wait_until(
      lock, duration, [&waiting_for_first_frame = waiting_for_first_frame_] {
        return !waiting_for_first_frame.load();
      });
  if (success) {
    return fml::Status();
  } else {
    return fml::Status(fml::StatusCode::kDeadlineExceeded, ""timeout"");
  }
}

bool Shell::ReloadSystemFonts() {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

  if (!engine_) {
    return false;
  }
  engine_->SetupDefaultFontManager();
  engine_->GetFontCollection().GetFontCollection()->ClearFontFamilyCache();
  // After system fonts are reloaded, we send a system channel message
  // to notify flutter framework.
  rapidjson::Document document;
  document.SetObject();
  auto& allocator = document.GetAllocator();
  rapidjson::Value message_value;
  message_value.SetString(kFontChange, allocator);
  document.AddMember(kTypeKey, message_value, allocator);

  rapidjson::StringBuffer buffer;
  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
  document.Accept(writer);
  std::string message = buffer.GetString();
  std::unique_ptr<PlatformMessage> fontsChangeMessage =
      std::make_unique<flutter::PlatformMessage>(
          kSystemChannel,
          fml::MallocMapping::Copy(message.c_str(), message.length()), nullptr);

  OnPlatformViewDispatchPlatformMessage(std::move(fontsChangeMessage));
  return true;
}

std::shared_ptr<const fml::SyncSwitch> Shell::GetIsGpuDisabledSyncSwitch()
    const {
  return is_gpu_disabled_sync_switch_;
}

void Shell::SetGpuAvailability(GpuAvailability availability) {
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
  switch (availability) {
    case GpuAvailability::kAvailable:
      is_gpu_disabled_sync_switch_->SetSwitch(false);
      return;
    case GpuAvailability::kFlushAndMakeUnavailable: {
      fml::AutoResetWaitableEvent latch;
      fml::TaskRunner::RunNowOrPostTask(
          task_runners_.GetIOTaskRunner(),
          [io_manager = io_manager_.get(), &latch]() {
            io_manager->GetSkiaUnrefQueue()->Drain();
            latch.Signal();
          });
      latch.Wait();
    }
      // FALLTHROUGH
    case GpuAvailability::kUnavailable:
      is_gpu_disabled_sync_switch_->SetSwitch(true);
      return;
    default:
      FML_DCHECK(false);
  }
}

void Shell::OnDisplayUpdates(DisplayUpdateType update_type,
                             std::vector<std::unique_ptr<Display>> displays) {
  display_manager_->HandleDisplayUpdates(update_type, std::move(displays));
}

fml::TimePoint Shell::GetCurrentTimePoint() {
  return fml::TimePoint::Now();
}

const std::shared_ptr<PlatformMessageHandler>&
Shell::GetPlatformMessageHandler() const {
  return platform_message_handler_;
}

}  // namespace flutter
",16319,True,2934.1400241408323,median
"/******************************************************************************
 * The MIT License (MIT)
 *
 * Copyright (c) 2019-2020 Baldur Karlsson
 *
 * 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 <algorithm>
#include ""driver/dxgi/dxgi_common.h""
#include ""driver/ihv/amd/official/DXExt/AmdExtD3DCommandListMarkerApi.h""
#include ""d3d12_command_list.h""
#include ""d3d12_command_queue.h""

WRAPPED_POOL_INST(WrappedID3D12CommandQueue);
WRAPPED_POOL_INST(WrappedID3D12GraphicsCommandList);

template <>
ID3D12GraphicsCommandList *Unwrap(ID3D12GraphicsCommandList *obj)
{
  if(obj == NULL)
    return NULL;

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetReal();
}

ID3D12GraphicsCommandList *Unwrap(ID3D12GraphicsCommandList1 *obj)
{
  if(obj == NULL)
    return NULL;

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetReal();
}

ID3D12GraphicsCommandList *Unwrap(ID3D12GraphicsCommandList2 *obj)
{
  if(obj == NULL)
    return NULL;

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetReal();
}

ID3D12GraphicsCommandList *Unwrap(ID3D12GraphicsCommandList3 *obj)
{
  if(obj == NULL)
    return NULL;

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetReal();
}

ID3D12GraphicsCommandList *Unwrap(ID3D12GraphicsCommandList4 *obj)
{
  if(obj == NULL)
    return NULL;

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetReal();
}

ID3D12GraphicsCommandList *Unwrap(ID3D12GraphicsCommandList5 *obj)
{
  if(obj == NULL)
    return NULL;

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetReal();
}

ID3D12GraphicsCommandList1 *Unwrap1(ID3D12GraphicsCommandList1 *obj)
{
  if(obj == NULL)
    return NULL;

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetReal1();
}

ID3D12GraphicsCommandList2 *Unwrap2(ID3D12GraphicsCommandList2 *obj)
{
  if(obj == NULL)
    return NULL;

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetReal2();
}

ID3D12GraphicsCommandList3 *Unwrap3(ID3D12GraphicsCommandList3 *obj)
{
  if(obj == NULL)
    return NULL;

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetReal3();
}

ID3D12GraphicsCommandList4 *Unwrap4(ID3D12GraphicsCommandList4 *obj)
{
  if(obj == NULL)
    return NULL;

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetReal4();
}

ID3D12GraphicsCommandList5 *Unwrap5(ID3D12GraphicsCommandList5 *obj)
{
  if(obj == NULL)
    return NULL;

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetReal5();
}

template <>
ID3D12CommandList *Unwrap(ID3D12CommandList *obj)
{
  if(obj == NULL)
    return NULL;

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetReal();
}

template <>
ResourceId GetResID(ID3D12GraphicsCommandList *obj)
{
  if(obj == NULL)
    return ResourceId();

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetResourceID();
}

template <>
ResourceId GetResID(ID3D12GraphicsCommandList1 *obj)
{
  if(obj == NULL)
    return ResourceId();

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetResourceID();
}

template <>
ResourceId GetResID(ID3D12GraphicsCommandList2 *obj)
{
  if(obj == NULL)
    return ResourceId();

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetResourceID();
}

template <>
ResourceId GetResID(ID3D12GraphicsCommandList3 *obj)
{
  if(obj == NULL)
    return ResourceId();

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetResourceID();
}

template <>
ResourceId GetResID(ID3D12GraphicsCommandList4 *obj)
{
  if(obj == NULL)
    return ResourceId();

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetResourceID();
}

template <>
ResourceId GetResID(ID3D12GraphicsCommandList5 *obj)
{
  if(obj == NULL)
    return ResourceId();

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetResourceID();
}

template <>
ResourceId GetResID(ID3D12CommandList *obj)
{
  if(obj == NULL)
    return ResourceId();

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetResourceID();
}

template <>
D3D12ResourceRecord *GetRecord(ID3D12GraphicsCommandList *obj)
{
  if(obj == NULL)
    return NULL;

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetResourceRecord();
}

template <>
D3D12ResourceRecord *GetRecord(ID3D12CommandList *obj)
{
  if(obj == NULL)
    return NULL;

  return ((WrappedID3D12GraphicsCommandList *)obj)->GetResourceRecord();
}

template <>
ID3D12CommandQueue *Unwrap(ID3D12CommandQueue *obj)
{
  if(obj == NULL)
    return NULL;

  return ((WrappedID3D12CommandQueue *)obj)->GetReal();
}

template <>
ResourceId GetResID(ID3D12CommandQueue *obj)
{
  if(obj == NULL)
    return ResourceId();

  return ((WrappedID3D12CommandQueue *)obj)->GetResourceID();
}

template <>
D3D12ResourceRecord *GetRecord(ID3D12CommandQueue *obj)
{
  if(obj == NULL)
    return NULL;

  return ((WrappedID3D12CommandQueue *)obj)->GetResourceRecord();
}

WrappedID3D12GraphicsCommandList *GetWrapped(ID3D12GraphicsCommandList1 *obj)
{
  return ((WrappedID3D12GraphicsCommandList *)obj);
}

WrappedID3D12GraphicsCommandList *GetWrapped(ID3D12GraphicsCommandList2 *obj)
{
  return ((WrappedID3D12GraphicsCommandList *)obj);
}

WrappedID3D12GraphicsCommandList *GetWrapped(ID3D12GraphicsCommandList3 *obj)
{
  return ((WrappedID3D12GraphicsCommandList *)obj);
}

WrappedID3D12GraphicsCommandList *GetWrapped(ID3D12GraphicsCommandList4 *obj)
{
  return ((WrappedID3D12GraphicsCommandList *)obj);
}

WrappedID3D12GraphicsCommandList *GetWrapped(ID3D12GraphicsCommandList5 *obj)
{
  return ((WrappedID3D12GraphicsCommandList *)obj);
}

ULONG STDMETHODCALLTYPE WrappedID3D12DebugCommandQueue::AddRef()
{
  if(m_pQueue)
    m_pQueue->AddRef();
  return 1;
}

ULONG STDMETHODCALLTYPE WrappedID3D12DebugCommandQueue::Release()
{
  if(m_pQueue)
    m_pQueue->Release();
  return 1;
}

ULONG STDMETHODCALLTYPE WrappedID3D12DebugCommandList::AddRef()
{
  if(m_pList)
    m_pList->AddRef();
  return 1;
}

ULONG STDMETHODCALLTYPE WrappedID3D12DebugCommandList::Release()
{
  if(m_pList)
    m_pList->Release();
  return 1;
}

HRESULT STDMETHODCALLTYPE WrappedDownlevelQueue::QueryInterface(REFIID riid, void **ppvObject)
{
  return m_pQueue.QueryInterface(riid, ppvObject);
}

ULONG STDMETHODCALLTYPE WrappedDownlevelQueue::AddRef()
{
  return m_pQueue.AddRef();
}

ULONG STDMETHODCALLTYPE WrappedDownlevelQueue::Release()
{
  return m_pQueue.Release();
}

HRESULT STDMETHODCALLTYPE WrappedDownlevelQueue::Present(ID3D12GraphicsCommandList *pOpenCommandList,
                                                         ID3D12Resource *pSourceTex2D, HWND hWindow,
                                                         D3D12_DOWNLEVEL_PRESENT_FLAGS Flags)
{
  return m_pQueue.Present(pOpenCommandList, pSourceTex2D, hWindow, Flags);
}

WrappedID3D12CommandQueue::WrappedID3D12CommandQueue(ID3D12CommandQueue *real,
                                                     WrappedID3D12Device *device, CaptureState &state)
    : RefCounter12(real), m_pDevice(device), m_State(state), m_WrappedDownlevel(*this)
{
  if(RenderDoc::Inst().GetCrashHandler())
    RenderDoc::Inst().GetCrashHandler()->RegisterMemoryRegion(this,
                                                              sizeof(WrappedID3D12CommandQueue));

  m_WrappedDebug.m_pQueue = this;
  m_pDownlevel = NULL;
  if(m_pReal)
  {
    m_pReal->QueryInterface(__uuidof(ID3D12DebugCommandQueue), (void **)&m_WrappedDebug.m_pReal);
    m_pReal->QueryInterface(__uuidof(ID3D12CommandQueueDownlevel), (void **)&m_pDownlevel);
  }

  if(RenderDoc::Inst().IsReplayApp())
  {
    m_ReplayList = new WrappedID3D12GraphicsCommandList(NULL, m_pDevice, state);

    m_ReplayList->SetCommandData(&m_Cmd);
  }

  // create a temporary and grab its resource ID
  m_ResourceID = ResourceIDGen::GetNewUniqueID();

  m_QueueRecord = NULL;
  m_CreationRecord = NULL;

  m_Cmd.m_pDevice = m_pDevice;

  if(!RenderDoc::Inst().IsReplayApp())
  {
    m_QueueRecord = m_pDevice->GetResourceManager()->AddResourceRecord(m_ResourceID);
    m_QueueRecord->type = Resource_CommandQueue;
    m_QueueRecord->DataInSerialiser = false;
    m_QueueRecord->InternalResource = true;
    m_QueueRecord->Length = 0;

    // a bit of a hack, we make a parallel resource record with the same lifetime as the command
    // queue. It will hold onto our create chunk and not get thrown away as we clear and re-fill
    // submissions into the queue record itself. We'll pull it into the capture by marking the
    // queues as referenced.
    m_CreationRecord =
        m_pDevice->GetResourceManager()->AddResourceRecord(ResourceIDGen::GetNewUniqueID());
    m_CreationRecord->type = Resource_CommandQueue;
    m_CreationRecord->InternalResource = true;
  }

  m_pDevice->GetResourceManager()->AddCurrentResource(GetResourceID(), this);

  m_pDevice->SoftRef();
}

WrappedID3D12CommandQueue::~WrappedID3D12CommandQueue()
{
  SAFE_DELETE(m_FrameReader);

  if(m_CreationRecord)
    m_CreationRecord->Delete(m_pDevice->GetResourceManager());

  if(m_QueueRecord)
    m_QueueRecord->Delete(m_pDevice->GetResourceManager());
  m_pDevice->GetResourceManager()->ReleaseCurrentResource(GetResourceID());
  m_pDevice->RemoveQueue(this);

  SAFE_RELEASE(m_pDownlevel);

  for(size_t i = 0; i < m_Cmd.m_IndirectBuffers.size(); i++)
    SAFE_RELEASE(m_Cmd.m_IndirectBuffers[i]);

  SAFE_RELEASE(m_WrappedDebug.m_pReal);
  SAFE_RELEASE(m_pReal);
}

HRESULT STDMETHODCALLTYPE WrappedID3D12CommandQueue::QueryInterface(REFIID riid, void **ppvObject)
{
  if(riid == __uuidof(IUnknown))
  {
    *ppvObject = (IUnknown *)(ID3D12CommandQueue *)this;
    AddRef();
    return S_OK;
  }
  else if(riid == __uuidof(ID3D12CommandQueue))
  {
    *ppvObject = (ID3D12CommandQueue *)this;
    AddRef();
    return S_OK;
  }
  else if(riid == __uuidof(ID3D12DebugCommandQueue))
  {
    if(m_WrappedDebug.m_pReal)
    {
      AddRef();
      *ppvObject = (ID3D12DebugCommandQueue *)&m_WrappedDebug;
      return S_OK;
    }
    else
    {
      return E_NOINTERFACE;
    }
  }
  else if(riid == __uuidof(ID3D12Pageable))
  {
    *ppvObject = (ID3D12Pageable *)this;
    AddRef();
    return S_OK;
  }
  else if(riid == __uuidof(ID3D12DeviceChild))
  {
    *ppvObject = (ID3D12DeviceChild *)this;
    AddRef();
    return S_OK;
  }
  else if(riid == __uuidof(ID3D12Object))
  {
    *ppvObject = (ID3D12DeviceChild *)this;
    AddRef();
    return S_OK;
  }
  else if(riid == __uuidof(ID3D12CommandQueueDownlevel))
  {
    if(m_pDownlevel)
    {
      *ppvObject = &m_WrappedDownlevel;
      AddRef();
      return S_OK;
    }
    else
    {
      return E_NOINTERFACE;
    }
  }
  else
  {
    WarnUnknownGUID(""ID3D12CommandQueue"", riid);
  }

  return RefCounter12::QueryInterface(riid, ppvObject);
}

void WrappedID3D12CommandQueue::ClearAfterCapture()
{
  // delete cmd buffers now - had to keep them alive until after serialiser flush.
  for(size_t i = 0; i < m_CmdListRecords.size(); i++)
    m_CmdListRecords[i]->Delete(GetResourceManager());

  m_CmdListRecords.clear();

  m_QueueRecord->DeleteChunks();
}

WriteSerialiser &WrappedID3D12CommandQueue::GetThreadSerialiser()
{
  return m_pDevice->GetThreadSerialiser();
}

rdcstr WrappedID3D12CommandQueue::GetChunkName(uint32_t idx)
{
  if((SystemChunk)idx < SystemChunk::FirstDriverChunk)
    return ToStr((SystemChunk)idx);

  return ToStr((D3D12Chunk)idx);
}

const APIEvent &WrappedID3D12CommandQueue::GetEvent(uint32_t eventId)
{
  // start at where the requested eventId would be
  size_t idx = eventId;

  // find the next valid event (some may be skipped)
  while(idx < m_Cmd.m_Events.size() - 1 && m_Cmd.m_Events[idx].eventId == 0)
    idx++;

  return m_Cmd.m_Events[RDCMIN(idx, m_Cmd.m_Events.size() - 1)];
}

bool WrappedID3D12CommandQueue::ProcessChunk(ReadSerialiser &ser, D3D12Chunk chunk)
{
  m_Cmd.m_AddedDrawcall = false;

  bool ret = false;

  switch(chunk)
  {
    case D3D12Chunk::Device_CreateConstantBufferView:
    case D3D12Chunk::Device_CreateShaderResourceView:
    case D3D12Chunk::Device_CreateUnorderedAccessView:
    case D3D12Chunk::Device_CreateRenderTargetView:
    case D3D12Chunk::Device_CreateDepthStencilView:
    case D3D12Chunk::Device_CreateSampler:
      ret = m_pDevice->Serialise_DynamicDescriptorWrite(ser, NULL);
      break;
    case D3D12Chunk::Device_CopyDescriptors:
    case D3D12Chunk::Device_CopyDescriptorsSimple:
      ret = m_pDevice->Serialise_DynamicDescriptorCopies(ser, rdcarray<DynamicDescriptorCopy>());
      break;

    case D3D12Chunk::Queue_ExecuteCommandLists:
      ret = Serialise_ExecuteCommandLists(ser, 0, NULL);
      break;
    case D3D12Chunk::Queue_Signal: ret = Serialise_Signal(ser, NULL, 0); break;
    case D3D12Chunk::Queue_Wait: ret = Serialise_Wait(ser, NULL, 0); break;
    case D3D12Chunk::Queue_UpdateTileMappings:
      ret = Serialise_UpdateTileMappings(ser, NULL, 0, NULL, NULL, NULL, 0, NULL, NULL, NULL,
                                         D3D12_TILE_MAPPING_FLAGS(0));
      break;
    case D3D12Chunk::Queue_CopyTileMappings:
      ret =
          Serialise_CopyTileMappings(ser, NULL, NULL, NULL, NULL, NULL, D3D12_TILE_MAPPING_FLAGS(0));
      break;
    case D3D12Chunk::Queue_BeginEvent: ret = Serialise_BeginEvent(ser, 0, NULL, 0); break;
    case D3D12Chunk::Queue_SetMarker: ret = Serialise_SetMarker(ser, 0, NULL, 0); break;
    case D3D12Chunk::Queue_EndEvent: ret = Serialise_EndEvent(ser); break;

    case D3D12Chunk::List_Close: ret = m_ReplayList->Serialise_Close(ser); break;
    case D3D12Chunk::List_Reset: ret = m_ReplayList->Serialise_Reset(ser, NULL, NULL); break;
    case D3D12Chunk::List_ResourceBarrier:
      ret = m_ReplayList->Serialise_ResourceBarrier(ser, 0, NULL);
      break;
    case D3D12Chunk::List_BeginQuery:
      ret = m_ReplayList->Serialise_BeginQuery(ser, NULL, D3D12_QUERY_TYPE(0), 0);
      break;
    case D3D12Chunk::List_EndQuery:
      ret = m_ReplayList->Serialise_EndQuery(ser, NULL, D3D12_QUERY_TYPE(0), 0);
      break;
    case D3D12Chunk::List_ResolveQueryData:
      ret = m_ReplayList->Serialise_ResolveQueryData(ser, NULL, D3D12_QUERY_TYPE(0), 0, 0, NULL, 0);
      break;
    case D3D12Chunk::List_SetPredication:
      ret = m_ReplayList->Serialise_SetPredication(ser, NULL, 0, D3D12_PREDICATION_OP(0));
      break;
    case D3D12Chunk::List_DrawIndexedInstanced:
      ret = m_ReplayList->Serialise_DrawIndexedInstanced(ser, 0, 0, 0, 0, 0);
      break;
    case D3D12Chunk::List_DrawInstanced:
      ret = m_ReplayList->Serialise_DrawInstanced(ser, 0, 0, 0, 0);
      break;
    case D3D12Chunk::List_Dispatch: ret = m_ReplayList->Serialise_Dispatch(ser, 0, 0, 0); break;
    case D3D12Chunk::List_ExecuteIndirect:
      ret = m_ReplayList->Serialise_ExecuteIndirect(ser, NULL, 0, NULL, 0, NULL, 0);
      break;
    case D3D12Chunk::List_ExecuteBundle:
      ret = m_ReplayList->Serialise_ExecuteBundle(ser, NULL);
      break;
    case D3D12Chunk::List_CopyBufferRegion:
      ret = m_ReplayList->Serialise_CopyBufferRegion(ser, NULL, 0, NULL, 0, 0);
      break;
    case D3D12Chunk::List_CopyTextureRegion:
      ret = m_ReplayList->Serialise_CopyTextureRegion(ser, NULL, 0, 0, 0, NULL, NULL);
      break;
    case D3D12Chunk::List_CopyResource:
      ret = m_ReplayList->Serialise_CopyResource(ser, NULL, NULL);
      break;
    case D3D12Chunk::List_ResolveSubresource:
      ret = m_ReplayList->Serialise_ResolveSubresource(ser, NULL, 0, NULL, 0, DXGI_FORMAT_UNKNOWN);
      break;
    case D3D12Chunk::List_ClearRenderTargetView:
      ret = m_ReplayList->Serialise_ClearRenderTargetView(ser, D3D12_CPU_DESCRIPTOR_HANDLE(),
                                                          (FLOAT *)NULL, 0, NULL);
      break;
    case D3D12Chunk::List_ClearDepthStencilView:
      ret = m_ReplayList->Serialise_ClearDepthStencilView(ser, D3D12_CPU_DESCRIPTOR_HANDLE(),
                                                          D3D12_CLEAR_FLAGS(0), 0.0f, 0, 0, NULL);
      break;
    case D3D12Chunk::List_ClearUnorderedAccessViewUint:
      ret = m_ReplayList->Serialise_ClearUnorderedAccessViewUint(
          ser, D3D12_GPU_DESCRIPTOR_HANDLE(), D3D12_CPU_DESCRIPTOR_HANDLE(), NULL, NULL, 0, NULL);
      break;
    case D3D12Chunk::List_ClearUnorderedAccessViewFloat:
      ret = m_ReplayList->Serialise_ClearUnorderedAccessViewFloat(
          ser, D3D12_GPU_DESCRIPTOR_HANDLE(), D3D12_CPU_DESCRIPTOR_HANDLE(), NULL, NULL, 0, NULL);
      break;
    case D3D12Chunk::List_DiscardResource:
      ret = m_ReplayList->Serialise_DiscardResource(ser, NULL, NULL);
      break;
    case D3D12Chunk::List_IASetPrimitiveTopology:
      ret = m_ReplayList->Serialise_IASetPrimitiveTopology(ser, D3D_PRIMITIVE_TOPOLOGY_UNDEFINED);
      break;
    case D3D12Chunk::List_IASetIndexBuffer:
      ret = m_ReplayList->Serialise_IASetIndexBuffer(ser, NULL);
      break;
    case D3D12Chunk::List_IASetVertexBuffers:
      ret = m_ReplayList->Serialise_IASetVertexBuffers(ser, 0, 0, NULL);
      break;
    case D3D12Chunk::List_SOSetTargets:
      ret = m_ReplayList->Serialise_SOSetTargets(ser, 0, 0, NULL);
      break;
    case D3D12Chunk::List_RSSetViewports:
      ret = m_ReplayList->Serialise_RSSetViewports(ser, 0, NULL);
      break;
    case D3D12Chunk::List_RSSetScissorRects:
      ret = m_ReplayList->Serialise_RSSetScissorRects(ser, 0, NULL);
      break;
    case D3D12Chunk::List_SetPipelineState:
      ret = m_ReplayList->Serialise_SetPipelineState(ser, NULL);
      break;
    case D3D12Chunk::List_SetDescriptorHeaps:
      ret = m_ReplayList->Serialise_SetDescriptorHeaps(ser, 0, NULL);
      break;
    case D3D12Chunk::List_OMSetRenderTargets:
      ret = m_ReplayList->Serialise_OMSetRenderTargets(ser, 0, NULL, FALSE, NULL);
      break;
    case D3D12Chunk::List_OMSetStencilRef:
      ret = m_ReplayList->Serialise_OMSetStencilRef(ser, 0);
      break;
    case D3D12Chunk::List_OMSetBlendFactor:
      ret = m_ReplayList->Serialise_OMSetBlendFactor(ser, NULL);
      break;
    case D3D12Chunk::List_SetGraphicsRootDescriptorTable:
      ret = m_ReplayList->Serialise_SetGraphicsRootDescriptorTable(ser, 0,
                                                                   D3D12_GPU_DESCRIPTOR_HANDLE());
      break;
    case D3D12Chunk::List_SetGraphicsRootSignature:
      ret = m_ReplayList->Serialise_SetGraphicsRootSignature(ser, NULL);
      break;
    case D3D12Chunk::List_SetGraphicsRoot32BitConstant:
      ret = m_ReplayList->Serialise_SetGraphicsRoot32BitConstant(ser, 0, 0, 0);
      break;
    case D3D12Chunk::List_SetGraphicsRoot32BitConstants:
      ret = m_ReplayList->Serialise_SetGraphicsRoot32BitConstants(ser, 0, 0, NULL, 0);
      break;
    case D3D12Chunk::List_SetGraphicsRootConstantBufferView:
      ret = m_ReplayList->Serialise_SetGraphicsRootConstantBufferView(ser, 0,
                                                                      D3D12_GPU_VIRTUAL_ADDRESS());
      break;
    case D3D12Chunk::List_SetGraphicsRootShaderResourceView:
      ret = m_ReplayList->Serialise_SetGraphicsRootShaderResourceView(ser, 0,
                                                                      D3D12_GPU_VIRTUAL_ADDRESS());
      break;
    case D3D12Chunk::List_SetGraphicsRootUnorderedAccessView:
      ret = m_ReplayList->Serialise_SetGraphicsRootUnorderedAccessView(ser, 0,
                                                                       D3D12_GPU_VIRTUAL_ADDRESS());
      break;
    case D3D12Chunk::List_SetComputeRootDescriptorTable:
      ret = m_ReplayList->Serialise_SetComputeRootDescriptorTable(ser, 0,
                                                                  D3D12_GPU_DESCRIPTOR_HANDLE());
      break;
    case D3D12Chunk::List_SetComputeRootSignature:
      ret = m_ReplayList->Serialise_SetComputeRootSignature(ser, NULL);
      break;
    case D3D12Chunk::List_SetComputeRoot32BitConstant:
      ret = m_ReplayList->Serialise_SetComputeRoot32BitConstant(ser, 0, 0, 0);
      break;
    case D3D12Chunk::List_SetComputeRoot32BitConstants:
      ret = m_ReplayList->Serialise_SetComputeRoot32BitConstants(ser, 0, 0, NULL, 0);
      break;
    case D3D12Chunk::List_SetComputeRootConstantBufferView:
      ret = m_ReplayList->Serialise_SetComputeRootConstantBufferView(ser, 0,
                                                                     D3D12_GPU_VIRTUAL_ADDRESS());
      break;
    case D3D12Chunk::List_SetComputeRootShaderResourceView:
      ret = m_ReplayList->Serialise_SetComputeRootShaderResourceView(ser, 0,
                                                                     D3D12_GPU_VIRTUAL_ADDRESS());
      break;
    case D3D12Chunk::List_SetComputeRootUnorderedAccessView:
      ret = m_ReplayList->Serialise_SetComputeRootUnorderedAccessView(ser, 0,
                                                                      D3D12_GPU_VIRTUAL_ADDRESS());
      break;
    case D3D12Chunk::List_CopyTiles:
      ret = m_ReplayList->Serialise_CopyTiles(ser, NULL, NULL, NULL, NULL, 0,
                                              D3D12_TILE_COPY_FLAGS(0));
      break;
    case D3D12Chunk::List_AtomicCopyBufferUINT:
      ret = m_ReplayList->Serialise_AtomicCopyBufferUINT(ser, NULL, 0, NULL, 0, 0, NULL, NULL);
      break;
    case D3D12Chunk::List_AtomicCopyBufferUINT64:
      ret = m_ReplayList->Serialise_AtomicCopyBufferUINT64(ser, NULL, 0, NULL, 0, 0, NULL, NULL);
      break;
    case D3D12Chunk::List_OMSetDepthBounds:
      ret = m_ReplayList->Serialise_OMSetDepthBounds(ser, 0.0f, 0.0f);
      break;
    case D3D12Chunk::List_ResolveSubresourceRegion:
      ret = m_ReplayList->Serialise_ResolveSubresourceRegion(
          ser, NULL, 0, 0, 0, NULL, 0, NULL, DXGI_FORMAT_UNKNOWN, D3D12_RESOLVE_MODE_DECOMPRESS);
      break;
    case D3D12Chunk::List_SetSamplePositions:
      ret = m_ReplayList->Serialise_SetSamplePositions(ser, 0, NULL, NULL);
      break;
    case D3D12Chunk::List_SetViewInstanceMask:
      ret = m_ReplayList->Serialise_SetViewInstanceMask(ser, 0);
      break;
    case D3D12Chunk::List_WriteBufferImmediate:
      ret = m_ReplayList->Serialise_WriteBufferImmediate(ser, 0, NULL, NULL);
      break;
    case D3D12Chunk::List_BeginRenderPass:
      ret = m_ReplayList->Serialise_BeginRenderPass(ser, 0, NULL, NULL, D3D12_RENDER_PASS_FLAG_NONE);
      break;
    case D3D12Chunk::List_EndRenderPass: ret = m_ReplayList->Serialise_EndRenderPass(ser); break;
    case D3D12Chunk::List_RSSetShadingRate:
      ret = m_ReplayList->Serialise_RSSetShadingRate(ser, D3D12_SHADING_RATE_1X1, NULL);
      break;
    case D3D12Chunk::List_RSSetShadingRateImage:
      ret = m_ReplayList->Serialise_RSSetShadingRateImage(ser, NULL);
      break;

    case D3D12Chunk::PushMarker: ret = m_ReplayList->Serialise_BeginEvent(ser, 0, NULL, 0); break;
    case D3D12Chunk::PopMarker: ret = m_ReplayList->Serialise_EndEvent(ser); break;
    case D3D12Chunk::SetMarker: ret = m_ReplayList->Serialise_SetMarker(ser, 0, NULL, 0); break;

    case D3D12Chunk::Resource_Unmap:
      ret = m_pDevice->Serialise_MapDataWrite(ser, NULL, 0, NULL, D3D12_RANGE());
      break;
    case D3D12Chunk::Resource_WriteToSubresource:
      ret = m_pDevice->Serialise_WriteToSubresource(ser, NULL, 0, NULL, NULL, 0, 0);
      break;
    case D3D12Chunk::List_IndirectSubCommand:
      // this is a fake chunk generated at runtime as part of indirect draws.
      // Just in case it gets exported and imported, completely ignore it.
      return true;

    case D3D12Chunk::Swapchain_Present: ret = m_pDevice->Serialise_Present(ser, NULL, 0, 0); break;

    case D3D12Chunk::List_ClearState:
      ret = m_ReplayList->Serialise_ClearState(ser, NULL);
      break;

    // in order to get a warning if we miss a case, we explicitly handle the device creation chunks
    // here. If we actually encounter one it's an error (we shouldn't see these inside the captured
    // frame itself)
    case D3D12Chunk::Device_CreateCommandQueue:
    case D3D12Chunk::Device_CreateCommandAllocator:
    case D3D12Chunk::Device_CreateCommandList:
    case D3D12Chunk::Device_CreateGraphicsPipeline:
    case D3D12Chunk::Device_CreateComputePipeline:
    case D3D12Chunk::Device_CreateDescriptorHeap:
    case D3D12Chunk::Device_CreateRootSignature:
    case D3D12Chunk::Device_CreateCommandSignature:
    case D3D12Chunk::Device_CreateHeap:
    case D3D12Chunk::Device_CreateCommittedResource:
    case D3D12Chunk::Device_CreatePlacedResource:
    case D3D12Chunk::Device_CreateReservedResource:
    case D3D12Chunk::Device_CreateQueryHeap:
    case D3D12Chunk::Device_CreateFence:
    case D3D12Chunk::SetName:
    case D3D12Chunk::SetShaderDebugPath:
    case D3D12Chunk::CreateSwapBuffer:
    case D3D12Chunk::Device_CreatePipelineState:
    case D3D12Chunk::Device_CreateHeapFromAddress:
    case D3D12Chunk::Device_CreateHeapFromFileMapping:
    case D3D12Chunk::Device_OpenSharedHandle:
    case D3D12Chunk::Device_CreateCommandList1:
    case D3D12Chunk::Device_CreateCommittedResource1:
    case D3D12Chunk::Device_CreateHeap1:
    case D3D12Chunk::Device_ExternalDXGIResource:
      RDCERR(""Unexpected chunk while processing frame: %s"", ToStr(chunk).c_str());
      return false;

    // no explicit default so that we have compiler warnings if a chunk isn't explicitly handled.
    case D3D12Chunk::Max: break;
  }

  {
    SystemChunk system = (SystemChunk)chunk;

    if(system == SystemChunk::CaptureEnd)
    {
      SERIALISE_ELEMENT_LOCAL(PresentedImage, ResourceId()).TypedAs(""ID3D12Resource *""_lit);

      SERIALISE_CHECK_READ_ERRORS();

      if(PresentedImage != ResourceId())
        m_Cmd.m_LastPresentedImage = PresentedImage;

      if(IsLoading(m_State) && m_Cmd.m_LastChunk != D3D12Chunk::Swapchain_Present)
      {
        m_Cmd.AddEvent();

        DrawcallDescription draw;
        draw.name = ""End of Capture"";
        draw.flags |= DrawFlags::Present;

        draw.copyDestination = m_Cmd.m_LastPresentedImage;

        m_Cmd.AddDrawcall(draw, true);
      }

      ret = true;
    }
    else if(!ret)
    {
      RDCERR(""Unrecognised Chunk type %s"", ToStr(chunk).c_str());
      return false;
    }
  }

  if(IsLoading(m_State))
  {
    if(chunk == D3D12Chunk::List_Reset || chunk == D3D12Chunk::List_Close)
    {
      // don't add these events - they will be handled when inserted in-line into queue submit
    }
    else if(chunk == D3D12Chunk::Queue_EndEvent)
    {
      // also ignore, this just pops the drawcall stack
    }
    else
    {
      if(!m_Cmd.m_AddedDrawcall)
        m_Cmd.AddEvent();
    }
  }

  m_Cmd.m_AddedDrawcall = false;

  return ret;
}

ReplayStatus WrappedID3D12CommandQueue::ReplayLog(CaptureState readType, uint32_t startEventID,
                                                  uint32_t endEventID, bool partial)
{
  m_State = readType;

  if(!m_FrameReader)
  {
    RDCERR(""Can't replay context capture without frame reader"");
    return ReplayStatus::InternalError;
  }

  m_FrameReader->SetOffset(0);

  ReadSerialiser ser(m_FrameReader, Ownership::Nothing);

  ser.SetStringDatabase(&m_StringDB);
  ser.SetUserData(GetResourceManager());
  ser.SetVersion(m_pDevice->GetLogVersion());

  if(IsLoading(m_State) || IsStructuredExporting(m_State))
  {
    ser.ConfigureStructuredExport(&GetChunkName, IsStructuredExporting(m_State));

    ser.GetStructuredFile().Swap(m_pDevice->GetStructuredFile());

    m_StructuredFile = &ser.GetStructuredFile();
  }
  else
  {
    m_StructuredFile = &m_pDevice->GetStructuredFile();
  }

  m_Cmd.m_StructuredFile = m_StructuredFile;

  SystemChunk header = ser.ReadChunk<SystemChunk>();
  RDCASSERTEQUAL(header, SystemChunk::CaptureBegin);

  if(partial)
    ser.SkipCurrentChunk();
  else
    m_pDevice->Serialise_BeginCaptureFrame(ser);

  ser.EndChunk();

  m_Cmd.m_RootEvents.clear();

  if(IsLoading(m_State))
  {
    m_pDevice->ApplyInitialContents();

    m_pDevice->ExecuteLists();
    m_pDevice->FlushLists();
  }

  if(IsActiveReplaying(m_State))
  {
    APIEvent ev = GetEvent(startEventID);
    m_Cmd.m_RootEventID = ev.eventId;

    // if not partial, we need to be sure to replay
    // past the command list records, so can't
    // skip to the file offset of the first event
    if(partial)
    {
      ser.GetReader()->SetOffset(ev.fileOffset);

      D3D12CommandData::DrawcallUse use(ev.fileOffset, 0);
      auto it = std::lower_bound(m_Cmd.m_DrawcallUses.begin(), m_Cmd.m_DrawcallUses.end(), use);

      if(it != m_Cmd.m_DrawcallUses.end())
      {
        BakedCmdListInfo &cmdInfo = m_Cmd.m_BakedCmdListInfo[it->cmdList];
        cmdInfo.curEventID = it->relativeEID;
      }
    }

    m_Cmd.m_FirstEventID = startEventID;
    m_Cmd.m_LastEventID = endEventID;
  }
  else
  {
    m_Cmd.m_RootEventID = 1;
    m_Cmd.m_RootDrawcallID = 1;
    m_Cmd.m_FirstEventID = 0;
    m_Cmd.m_LastEventID = ~0U;
  }

  uint64_t startOffset = ser.GetReader()->GetOffset();

  for(;;)
  {
    if(IsActiveReplaying(m_State) && m_Cmd.m_RootEventID > endEventID)
    {
      // we can just break out if we've done all the events desired.
      // note that the command list events aren't 'real' and we just blaze through them
      break;
    }

    m_Cmd.m_CurChunkOffset = ser.GetReader()->GetOffset();

    D3D12Chunk context = ser.ReadChunk<D3D12Chunk>();

    if(ser.GetReader()->IsErrored())
      return ReplayStatus::APIDataCorrupted;

    m_Cmd.m_ChunkMetadata = ser.ChunkMetadata();

    m_Cmd.m_LastCmdListID = ResourceId();

    bool success = ProcessChunk(ser, context);

    ser.EndChunk();

    if(ser.GetReader()->IsErrored())
      return ReplayStatus::APIDataCorrupted;

    // if there wasn't a serialisation error, but the chunk didn't succeed, then it's an API replay
    // failure.
    if(!success)
      return m_FailedReplayStatus;

    RenderDoc::Inst().SetProgress(
        LoadProgress::FrameEventsRead,
        float(m_Cmd.m_CurChunkOffset - startOffset) / float(ser.GetReader()->GetSize()));

    if((SystemChunk)context == SystemChunk::CaptureEnd || ser.GetReader()->AtEnd())
      break;

    // break out if we were only executing one event
    if(IsActiveReplaying(m_State) && startEventID == endEventID)
      break;

    m_Cmd.m_LastChunk = context;

    // increment root event ID either if we didn't just replay a cmd
    // buffer event, OR if we are doing a frame sub-section replay,
    // in which case it's up to the calling code to make sure we only
    // replay inside a command list (if we crossed command list
    // boundaries, the event IDs would no longer match up).
    if(m_Cmd.m_LastCmdListID == ResourceId() || startEventID > 1)
    {
      m_Cmd.m_RootEventID++;

      if(startEventID > 1)
        ser.GetReader()->SetOffset(GetEvent(m_Cmd.m_RootEventID).fileOffset);
    }
    else
    {
      m_Cmd.m_BakedCmdListInfo[m_Cmd.m_LastCmdListID].curEventID++;
    }
  }

  // swap the structure back now that we've accumulated the frame as well.
  if(IsLoading(m_State) || IsStructuredExporting(m_State))
    ser.GetStructuredFile().Swap(m_pDevice->GetStructuredFile());

  m_StructuredFile = NULL;

  for(size_t i = 0; i < m_Cmd.m_RerecordCmdList.size(); i++)
    SAFE_RELEASE(m_Cmd.m_RerecordCmdList[i]);

  m_Cmd.m_RerecordCmds.clear();
  m_Cmd.m_RerecordCmdList.clear();

  return ReplayStatus::Succeeded;
}

WrappedID3D12GraphicsCommandList::WrappedID3D12GraphicsCommandList(ID3D12GraphicsCommandList *real,
                                                                   WrappedID3D12Device *device,
                                                                   CaptureState &state)
    : m_RefCounter(real, false), m_pList(real), m_pDevice(device), m_State(state)
{
  if(RenderDoc::Inst().GetCrashHandler())
    RenderDoc::Inst().GetCrashHandler()->RegisterMemoryRegion(
        this, sizeof(WrappedID3D12GraphicsCommandList));

  m_pList1 = NULL;
  m_pList2 = NULL;
  m_pList3 = NULL;
  m_pList4 = NULL;
  m_pList5 = NULL;

  m_WrappedDebug.m_pList = this;
  if(m_pList)
  {
    m_pList->QueryInterface(__uuidof(ID3D12DebugCommandList), (void **)&m_WrappedDebug.m_pReal);
    m_pList->QueryInterface(__uuidof(ID3D12DebugCommandList1), (void **)&m_WrappedDebug.m_pReal1);
    m_pList->QueryInterface(__uuidof(ID3D12DebugCommandList2), (void **)&m_WrappedDebug.m_pReal2);

    m_pList->QueryInterface(__uuidof(ID3D12GraphicsCommandList1), (void **)&m_pList1);
    m_pList->QueryInterface(__uuidof(ID3D12GraphicsCommandList2), (void **)&m_pList2);
    m_pList->QueryInterface(__uuidof(ID3D12GraphicsCommandList3), (void **)&m_pList3);
    m_pList->QueryInterface(__uuidof(ID3D12GraphicsCommandList4), (void **)&m_pList4);
    m_pList->QueryInterface(__uuidof(ID3D12GraphicsCommandList5), (void **)&m_pList5);
  }

  // create a temporary and grab its resource ID
  m_ResourceID = ResourceIDGen::GetNewUniqueID();

  RDCEraseEl(m_Init);

  m_ListRecord = NULL;
  m_CreationRecord = NULL;
  m_Cmd = NULL;

  m_CurGfxRootSig = NULL;
  m_CurCompRootSig = NULL;

  if(!RenderDoc::Inst().IsReplayApp())
  {
    m_ListRecord = m_pDevice->GetResourceManager()->AddResourceRecord(m_ResourceID);
    m_ListRecord->type = Resource_GraphicsCommandList;
    m_ListRecord->DataInSerialiser = false;
    m_ListRecord->InternalResource = true;
    m_ListRecord->Length = 0;

    m_ListRecord->cmdInfo = new CmdListRecordingInfo();

    // this is set up in the implicit Reset() right after creation
    m_ListRecord->bakedCommands = NULL;

    // a bit of a hack, we make a parallel resource record with the same lifetime as the command
    // list and make it a parent, so it will hold onto our create chunk and not try to
    // record it (and throw it away with baked commands that are unused), then it'll be pulled
    // into the capture.
    m_CreationRecord =
        m_pDevice->GetResourceManager()->AddResourceRecord(ResourceIDGen::GetNewUniqueID());
    m_CreationRecord->type = Resource_GraphicsCommandList;
    m_CreationRecord->InternalResource = true;

    m_ListRecord->AddParent(m_CreationRecord);
  }
  else
  {
    m_Cmd = m_pDevice->GetQueue()->GetCommandData();
  }

  if(m_pList)
  {
    bool ret = m_pDevice->GetResourceManager()->AddWrapper(this, m_pList);
    if(!ret)
      RDCERR(""Error adding wrapper for ID3D12GraphicsCommandList"");
  }

  m_pDevice->GetResourceManager()->AddCurrentResource(GetResourceID(), this);

  m_pDevice->SoftRef();
}

WrappedID3D12GraphicsCommandList::~WrappedID3D12GraphicsCommandList()
{
  SAFE_RELEASE(m_AMDMarkers);

  if(m_pList)
    m_pDevice->GetResourceManager()->RemoveWrapper(m_pList);

  if(m_CreationRecord)
    m_CreationRecord->Delete(m_pDevice->GetResourceManager());

  if(m_ListRecord && m_ListRecord->bakedCommands)
    m_ListRecord->bakedCommands->Delete(m_pDevice->GetResourceManager());

  if(m_ListRecord)
    m_ListRecord->Delete(m_pDevice->GetResourceManager());

  m_pDevice->GetResourceManager()->ReleaseCurrentResource(GetResourceID());

  SAFE_RELEASE(m_WrappedDebug.m_pReal);
  SAFE_RELEASE(m_WrappedDebug.m_pReal1);
  SAFE_RELEASE(m_WrappedDebug.m_pReal2);
  SAFE_RELEASE(m_pList5);
  SAFE_RELEASE(m_pList4);
  SAFE_RELEASE(m_pList3);
  SAFE_RELEASE(m_pList2);
  SAFE_RELEASE(m_pList1);
  SAFE_RELEASE(m_pList);
}

bool WrappedID3D12GraphicsCommandList::ValidateRootGPUVA(D3D12_GPU_VIRTUAL_ADDRESS buffer)
{
  if(buffer == 0)
  {
    // abort, we don't have this buffer. Print errors while reading
    if(IsLoading(m_State))
    {
      m_pDevice->AddDebugMessage(MessageCategory::Resource_Manipulation, MessageSeverity::Medium,
                                 MessageSource::IncorrectAPIUse,
                                 ""Binding 0 as a GPU Virtual Address in a root constant is ""
                                 ""invalid. This call will be dropped during replay."");
    }

    return true;
  }

  return false;
}

WriteSerialiser &WrappedID3D12GraphicsCommandList::GetThreadSerialiser()
{
  return m_pDevice->GetThreadSerialiser();
}

rdcstr WrappedID3D12GraphicsCommandList::GetChunkName(uint32_t idx)
{
  if((SystemChunk)idx < SystemChunk::FirstDriverChunk)
    return ToStr((SystemChunk)idx);

  return ToStr((D3D12Chunk)idx);
}

HRESULT STDMETHODCALLTYPE WrappedID3D12GraphicsCommandList::QueryInterface(REFIID riid,
                                                                           void **ppvObject)
{
  if(riid == __uuidof(IUnknown))
  {
    *ppvObject = (IUnknown *)(ID3D12GraphicsCommandList *)this;
    AddRef();
    return S_OK;
  }
  else if(riid == __uuidof(ID3D12GraphicsCommandList))
  {
    *ppvObject = (ID3D12GraphicsCommandList *)this;
    AddRef();
    return S_OK;
  }
  else if(riid == __uuidof(ID3D12DebugCommandList))
  {
    if(m_WrappedDebug.m_pReal)
    {
      AddRef();
      *ppvObject = (ID3D12DebugCommandList *)&m_WrappedDebug;
      return S_OK;
    }
    else
    {
      return E_NOINTERFACE;
    }
  }
  else if(riid == __uuidof(ID3D12DebugCommandList1))
  {
    if(m_WrappedDebug.m_pReal1)
    {
      AddRef();
      *ppvObject = (ID3D12DebugCommandList1 *)&m_WrappedDebug;
      return S_OK;
    }
    else
    {
      return E_NOINTERFACE;
    }
  }
  else if(riid == __uuidof(ID3D12DebugCommandList2))
  {
    if(m_WrappedDebug.m_pReal2)
    {
      AddRef();
      *ppvObject = (ID3D12DebugCommandList2 *)&m_WrappedDebug;
      return S_OK;
    }
    else
    {
      return E_NOINTERFACE;
    }
  }
  else if(riid == __uuidof(ID3D12GraphicsCommandList1))
  {
    if(m_pList1)
    {
      *ppvObject = (ID3D12GraphicsCommandList1 *)this;
      AddRef();
      return S_OK;
    }
    else
    {
      return E_NOINTERFACE;
    }
  }
  else if(riid == __uuidof(ID3D12GraphicsCommandList2))
  {
    if(m_pList2)
    {
      *ppvObject = (ID3D12GraphicsCommandList2 *)this;
      AddRef();
      return S_OK;
    }
    else
    {
      return E_NOINTERFACE;
    }
  }
  else if(riid == __uuidof(ID3D12GraphicsCommandList3))
  {
    if(m_pList3)
    {
      *ppvObject = (ID3D12GraphicsCommandList3 *)this;
      AddRef();
      return S_OK;
    }
    else
    {
      return E_NOINTERFACE;
    }
  }
  else if(riid == __uuidof(ID3D12GraphicsCommandList4))
  {
    if(m_pList4)
    {
      *ppvObject = (ID3D12GraphicsCommandList4 *)this;
      AddRef();
      return S_OK;
    }
    else
    {
      return E_NOINTERFACE;
    }
  }
  else if(riid == __uuidof(ID3D12GraphicsCommandList5))
  {
    if(m_pList5)
    {
      *ppvObject = (ID3D12GraphicsCommandList5 *)this;
      AddRef();
      return S_OK;
    }
    else
    {
      return E_NOINTERFACE;
    }
  }
  else if(riid == __uuidof(ID3D12GraphicsCommandList6))
  {
    return E_NOINTERFACE;
  }
  else if(riid == __uuidof(ID3D12CommandList))
  {
    *ppvObject = (ID3D12CommandList *)this;
    AddRef();
    return S_OK;
  }
  else if(riid == __uuidof(ID3D12Pageable))
  {
    *ppvObject = (ID3D12Pageable *)this;
    AddRef();
    return S_OK;
  }
  else if(riid == __uuidof(ID3D12DeviceChild))
  {
    *ppvObject = (ID3D12DeviceChild *)this;
    AddRef();
    return S_OK;
  }
  else if(riid == __uuidof(ID3D12Object))
  {
    *ppvObject = (ID3D12DeviceChild *)this;
    AddRef();
    return S_OK;
  }
  else
  {
    WarnUnknownGUID(""ID3D12GraphicsCommandList"", riid);
  }

  return m_RefCounter.QueryInterface(riid, ppvObject);
}

void BakedCmdListInfo::ShiftForRemoved(uint32_t shiftDrawID, uint32_t shiftEID, size_t idx)
{
  rdcarray<D3D12DrawcallTreeNode> &draws = draw->children;

  drawCount -= shiftDrawID;
  eventCount -= shiftEID;

  if(idx < draws.size())
  {
    for(size_t i = idx; i < draws.size(); i++)
    {
      // should have no children as we don't push in for markers since they
      // can cross command list boundaries.
      RDCASSERT(draws[i].children.empty());

      draws[i].draw.eventId -= shiftEID;
      draws[i].draw.drawcallId -= shiftDrawID;

      for(APIEvent &ev : draws[i].draw.events)
        ev.eventId -= shiftEID;
    }

    uint32_t lastEID = draws[idx].draw.eventId;

    // shift any resource usage for drawcalls after the removed section
    for(size_t i = 0; i < draw->resourceUsage.size(); i++)
    {
      if(draw->resourceUsage[i].second.eventId >= lastEID)
        draw->resourceUsage[i].second.eventId -= shiftEID;
    }

    // patch any subsequent executes
    for(size_t i = 0; i < executeEvents.size(); i++)
    {
      if(executeEvents[i].baseEvent >= lastEID)
      {
        executeEvents[i].baseEvent -= shiftEID;

        if(executeEvents[i].lastEvent > 0)
          executeEvents[i].lastEvent -= shiftEID;
      }
    }
  }
}

D3D12CommandData::D3D12CommandData()
{
  m_CurChunkOffset = 0;

  m_IndirectOffset = 0;

  m_RootEventID = 1;
  m_RootDrawcallID = 1;
  m_FirstEventID = 0;
  m_LastEventID = ~0U;

  m_StructuredFile = NULL;

  m_pDevice = NULL;

  m_DrawcallCallback = NULL;

  m_AddedDrawcall = false;

  m_RootDrawcallStack.push_back(&m_ParentDrawcall);
}

void D3D12CommandData::GetIndirectBuffer(size_t size, ID3D12Resource **buf, uint64_t *offs)
{
  // check if we need to allocate a new buffer
  if(m_IndirectBuffers.empty() || m_IndirectOffset + size > m_IndirectSize)
  {
    D3D12_RESOURCE_DESC indirectDesc;
    indirectDesc.Alignment = 0;
    indirectDesc.DepthOrArraySize = 1;
    indirectDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
    indirectDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
    indirectDesc.Format = DXGI_FORMAT_UNKNOWN;
    indirectDesc.Height = 1;
    indirectDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
    indirectDesc.MipLevels = 1;
    indirectDesc.SampleDesc.Count = 1;
    indirectDesc.SampleDesc.Quality = 0;
    indirectDesc.Width = m_IndirectSize;

    // create a custom heap that sits in CPU memory and is mappable, but we can
    // use for indirect args (unlike upload and readback).
    D3D12_HEAP_PROPERTIES heapProps;
    heapProps.Type = D3D12_HEAP_TYPE_CUSTOM;
    heapProps.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE;
    heapProps.MemoryPoolPreference = D3D12_MEMORY_POOL_L0;
    heapProps.CreationNodeMask = 1;
    heapProps.VisibleNodeMask = 1;

    ID3D12Resource *argbuf = NULL;

    HRESULT hr = m_pDevice->CreateCommittedResource(&heapProps, D3D12_HEAP_FLAG_NONE, &indirectDesc,
                                                    D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT, NULL,
                                                    __uuidof(ID3D12Resource), (void **)&argbuf);

    SetObjName(argbuf, StringFormat::Fmt(""Indirect Arg Buf (%llu bytes)"", (uint64_t)size));

    if(FAILED(hr))
      RDCERR(""Failed to create indirect buffer, HRESULT: %s"", ToStr(hr).c_str());

    m_IndirectBuffers.push_back(argbuf);
    m_IndirectOffset = 0;
  }

  *buf = m_IndirectBuffers.back();
  *offs = m_IndirectOffset;

  m_IndirectOffset = AlignUp16(m_IndirectOffset + size);
}

uint32_t D3D12CommandData::HandlePreCallback(ID3D12GraphicsCommandListX *list, bool dispatch,
                                             uint32_t multiDrawOffset)
{
  if(!m_DrawcallCallback)
    return 0;

  // look up the EID this drawcall came from
  DrawcallUse use(m_CurChunkOffset, 0);
  auto it = std::lower_bound(m_DrawcallUses.begin(), m_DrawcallUses.end(), use);

  if(it == m_DrawcallUses.end())
  {
    RDCERR(""Couldn't find drawcall use entry for %llu"", m_CurChunkOffset);
    return 0;
  }

  uint32_t eventId = it->eventId;

  RDCASSERT(eventId != 0);

  // handle all aliases of this drawcall as long as it's not a multidraw
  const DrawcallDescription *draw = m_pDevice->GetDrawcall(eventId);

  if(draw == NULL || !(draw->flags & DrawFlags::MultiDraw))
  {
    ++it;
    while(it != m_DrawcallUses.end() && it->fileOffset == m_CurChunkOffset)
    {
      m_DrawcallCallback->AliasEvent(eventId, it->eventId);
      ++it;
    }
  }

  eventId += multiDrawOffset;

  if(dispatch)
    m_DrawcallCallback->PreDispatch(eventId, list);
  else
    m_DrawcallCallback->PreDraw(eventId, list);

  return eventId;
}

bool D3D12CommandData::InRerecordRange(ResourceId cmdid)
{
  // if we have an outside command list, assume the range is valid and we're replaying all events
  // onto it.
  if(m_OutsideCmdList != NULL)
    return true;

  // if not, check if we're one of the actual partial command buffers and check to see if we're in
  // the range for their partial replay.
  for(int p = 0; p < ePartialNum; p++)
  {
    if(cmdid == m_Partial[p].partialParent)
    {
      return m_BakedCmdListInfo[m_Partial[p].partialParent].curEventID <=
             m_LastEventID - m_Partial[p].baseEvent;
    }
  }

  // otherwise just check if we have a re-record command list for this, as then we're doing a full
  // re-record and replay
  return m_RerecordCmds.find(cmdid) != m_RerecordCmds.end();
}

bool D3D12CommandData::HasRerecordCmdList(ResourceId cmdid)
{
  if(m_OutsideCmdList != NULL)
    return true;

  return m_RerecordCmds.find(cmdid) != m_RerecordCmds.end();
}

bool D3D12CommandData::IsPartialCmdList(ResourceId cmdid)
{
  if(m_OutsideCmdList != NULL)
    return true;

  for(int p = 0; p < ePartialNum; p++)
    if(cmdid == m_Partial[p].partialParent)
      return true;

  return false;
}

ID3D12GraphicsCommandListX *D3D12CommandData::RerecordCmdList(ResourceId cmdid,
                                                              PartialReplayIndex partialType)
{
  if(m_OutsideCmdList != NULL)
    return m_OutsideCmdList;

  auto it = m_RerecordCmds.find(cmdid);

  if(it == m_RerecordCmds.end())
  {
    RDCERR(""Didn't generate re-record command for %s"", ToStr(cmdid).c_str());
    return NULL;
  }

  return it->second;
}

bool D3D12CommandData::HasNonMarkerEvents(ResourceId cmdBuffer)
{
  for(const APIEvent &ev : m_BakedCmdListInfo[cmdBuffer].curEvents)
  {
    D3D12Chunk chunk = (D3D12Chunk)m_StructuredFile->chunks[ev.chunkIndex]->metadata.chunkID;
    if(chunk != D3D12Chunk::PushMarker && chunk != D3D12Chunk::PopMarker)
      return true;
  }

  return false;
}

void D3D12CommandData::AddEvent()
{
  APIEvent apievent;

  apievent.fileOffset = m_CurChunkOffset;
  apievent.eventId = m_LastCmdListID != ResourceId() ? m_BakedCmdListInfo[m_LastCmdListID].curEventID
                                                     : m_RootEventID;

  apievent.chunkIndex = uint32_t(m_StructuredFile->chunks.size() - 1);

  apievent.callstack = m_ChunkMetadata.callstack;

  // if we're using replay-time debug messages, fetch them now since we can do better to correlate
  // to events on replay
  if(m_pDevice->GetReplayOptions().apiValidation)
    m_EventMessages = m_pDevice->GetDebugMessages();

  for(size_t i = 0; i < m_EventMessages.size(); i++)
    m_EventMessages[i].eventId = apievent.eventId;

  if(m_LastCmdListID != ResourceId())
  {
    m_BakedCmdListInfo[m_LastCmdListID].curEvents.push_back(apievent);

    rdcarray<DebugMessage> &msgs = m_BakedCmdListInfo[m_LastCmdListID].debugMessages;

    msgs.append(m_EventMessages);
  }
  else
  {
    m_RootEvents.push_back(apievent);
    m_Events.resize(apievent.eventId + 1);
    m_Events[apievent.eventId] = apievent;

    for(auto it = m_EventMessages.begin(); it != m_EventMessages.end(); ++it)
      m_pDevice->AddDebugMessage(*it);
  }

  m_EventMessages.clear();
}

void D3D12CommandData::AddUsage(D3D12DrawcallTreeNode &drawNode, ResourceId id, uint32_t EID,
                                ResourceUsage usage)
{
  if(id == ResourceId())
    return;

  drawNode.resourceUsage.push_back(make_rdcpair(id, EventUsage(EID, usage)));
}

void D3D12CommandData::AddUsage(ResourceId id, ResourceUsage usage)
{
  m_ResourceUses[id].push_back(EventUsage(m_RootEventID, usage));
}

void D3D12CommandData::AddUsage(const D3D12RenderState &state, D3D12DrawcallTreeNode &drawNode)
{
  DrawcallDescription &d = drawNode.draw;

  uint32_t e = d.eventId;

  DrawFlags DrawMask = DrawFlags::Drawcall | DrawFlags::Dispatch;
  if(!(d.flags & DrawMask))
    return;

  static bool hugeRangeWarned = false;

  const D3D12RenderState::RootSignature *rootdata = NULL;

  if((d.flags & DrawFlags::Dispatch) && state.compute.rootsig != ResourceId())
  {
    rootdata = &state.compute;
  }
  else if(state.graphics.rootsig != ResourceId())
  {
    rootdata = &state.graphics;

    if(d.flags & DrawFlags::Indexed && state.ibuffer.buf != ResourceId())
      drawNode.resourceUsage.push_back(
          make_rdcpair(state.ibuffer.buf, EventUsage(e, ResourceUsage::IndexBuffer)));

    for(size_t i = 0; i < state.vbuffers.size(); i++)
    {
      if(state.vbuffers[i].buf != ResourceId())
        drawNode.resourceUsage.push_back(
            make_rdcpair(state.vbuffers[i].buf, EventUsage(e, ResourceUsage::VertexBuffer)));
    }

    for(size_t i = 0; i < state.streamouts.size(); i++)
    {
      if(state.streamouts[i].buf != ResourceId())
        drawNode.resourceUsage.push_back(
            make_rdcpair(state.streamouts[i].buf, EventUsage(e, ResourceUsage::StreamOut)));
      if(state.streamouts[i].countbuf != ResourceId())
        drawNode.resourceUsage.push_back(
            make_rdcpair(state.streamouts[i].countbuf, EventUsage(e, ResourceUsage::StreamOut)));
    }

    rdcarray<ResourceId> rts = state.GetRTVIDs();

    for(size_t i = 0; i < rts.size(); i++)
    {
      if(rts[i] != ResourceId())
        drawNode.resourceUsage.push_back(
            make_rdcpair(rts[i], EventUsage(e, ResourceUsage::ColorTarget)));
    }

    ResourceId id = state.GetDSVID();
    if(id != ResourceId())
      drawNode.resourceUsage.push_back(
          make_rdcpair(id, EventUsage(e, ResourceUsage::DepthStencilTarget)));
  }

  if(rootdata)
  {
    WrappedID3D12RootSignature *sig =
        m_pDevice->GetResourceManager()->GetCurrentAs<WrappedID3D12RootSignature>(rootdata->rootsig);

    for(size_t rootEl = 0; rootEl < sig->sig.Parameters.size(); rootEl++)
    {
      if(rootEl >= rootdata->sigelems.size())
        break;

      const D3D12RootSignatureParameter &p = sig->sig.Parameters[rootEl];
      const D3D12RenderState::SignatureElement &el = rootdata->sigelems[rootEl];

      ResourceUsage cb = ResourceUsage::CS_Constants;
      ResourceUsage ro = ResourceUsage::CS_Resource;
      ResourceUsage rw = ResourceUsage::CS_RWResource;

      if(rootdata == &state.graphics)
      {
        if(p.ShaderVisibility == D3D12_SHADER_VISIBILITY_ALL)
        {
          cb = ResourceUsage::All_Constants;
          ro = ResourceUsage::All_Resource;
          rw = ResourceUsage::All_RWResource;
        }
        else
        {
          cb = CBUsage(p.ShaderVisibility - D3D12_SHADER_VISIBILITY_VERTEX);
          ro = ResUsage(p.ShaderVisibility - D3D12_SHADER_VISIBILITY_VERTEX);
          rw = RWResUsage(p.ShaderVisibility - D3D12_SHADER_VISIBILITY_VERTEX);
        }
      }

      if(p.ParameterType == D3D12_ROOT_PARAMETER_TYPE_CBV && el.type == eRootCBV)
      {
        AddUsage(drawNode, el.id, e, cb);
      }
      else if(p.ParameterType == D3D12_ROOT_PARAMETER_TYPE_SRV && el.type == eRootSRV)
      {
        AddUsage(drawNode, el.id, e, ro);
      }
      else if(p.ParameterType == D3D12_ROOT_PARAMETER_TYPE_UAV && el.type == eRootUAV)
      {
        AddUsage(drawNode, el.id, e, rw);
      }
      else if(p.ParameterType == D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE && el.type == eRootTable)
      {
        WrappedID3D12DescriptorHeap *heap =
            m_pDevice->GetResourceManager()->GetCurrentAs<WrappedID3D12DescriptorHeap>(el.id);

        if(heap == NULL)
          continue;

        UINT prevTableOffset = 0;

        for(size_t r = 0; r < p.ranges.size(); r++)
        {
          const D3D12_DESCRIPTOR_RANGE1 &range = p.ranges[r];

          UINT offset = range.OffsetInDescriptorsFromTableStart;

          if(range.OffsetInDescriptorsFromTableStart == D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND)
            offset = prevTableOffset;

          D3D12Descriptor *desc = (D3D12Descriptor *)heap->GetCPUDescriptorHandleForHeapStart().ptr;
          desc += el.offset;
          desc += offset;

          UINT num = range.NumDescriptors;

          if(num == UINT_MAX)
          {
            // find out how many descriptors are left after
            num = heap->GetNumDescriptors() - offset - UINT(el.offset);
          }

          prevTableOffset = offset + num;

          if(range.RangeType == D3D12_DESCRIPTOR_RANGE_TYPE_CBV)
          {
            EventUsage usage(e, cb);

            if(num > 1000)
            {
              if(!hugeRangeWarned)
                RDCWARN(""Skipping large, most likely 'bindless', descriptor range"");
              hugeRangeWarned = true;
            }
            else
            {
              for(UINT i = 0; i < num; i++)
              {
                ResourceId id =
                    WrappedID3D12Resource1::GetResIDFromAddr(desc->GetCBV().BufferLocation);

                AddUsage(drawNode, id, e, cb);

                desc++;
              }
            }
          }
          else if(range.RangeType == D3D12_DESCRIPTOR_RANGE_TYPE_SRV ||
                  range.RangeType == D3D12_DESCRIPTOR_RANGE_TYPE_UAV)
          {
            ResourceUsage usage = range.RangeType == D3D12_DESCRIPTOR_RANGE_TYPE_SRV ? ro : rw;

            if(num > 1000)
            {
              if(!hugeRangeWarned)
                RDCWARN(""Skipping large, most likely 'bindless', descriptor range"");
              hugeRangeWarned = true;
            }
            else
            {
              for(UINT i = 0; i < num; i++)
              {
                AddUsage(drawNode, desc->GetResResourceId(), e, usage);

                desc++;
              }
            }
          }
        }
      }
    }
  }
}

void D3D12CommandData::AddDrawcall(const DrawcallDescription &d, bool hasEvents, bool addUsage)
{
  m_AddedDrawcall = true;

  DrawcallDescription draw = d;
  draw.eventId = m_LastCmdListID != ResourceId() ? m_BakedCmdListInfo[m_LastCmdListID].curEventID
                                                 : m_RootEventID;
  draw.drawcallId = m_LastCmdListID != ResourceId() ? m_BakedCmdListInfo[m_LastCmdListID].drawCount
                                                    : m_RootDrawcallID;

  for(int i = 0; i < 8; i++)
    draw.outputs[i] = ResourceId();

  draw.depthOut = ResourceId();

  draw.indexByteWidth = 0;
  draw.topology = Topology::Unknown;

  if(m_LastCmdListID != ResourceId())
  {
    draw.topology = MakePrimitiveTopology(m_BakedCmdListInfo[m_LastCmdListID].state.topo);
    draw.indexByteWidth = m_BakedCmdListInfo[m_LastCmdListID].state.ibuffer.bytewidth;

    rdcarray<ResourceId> rts = m_BakedCmdListInfo[m_LastCmdListID].state.GetRTVIDs();

    for(size_t i = 0; i < ARRAY_COUNT(draw.outputs); i++)
    {
      if(i < rts.size())
        draw.outputs[i] = m_pDevice->GetResourceManager()->GetOriginalID(rts[i]);
      else
        draw.outputs[i] = ResourceId();
    }

    draw.depthOut = m_pDevice->GetResourceManager()->GetOriginalID(
        m_BakedCmdListInfo[m_LastCmdListID].state.GetDSVID());
  }

  // markers don't increment drawcall ID
  DrawFlags MarkerMask = DrawFlags::SetMarker | DrawFlags::PushMarker | DrawFlags::PassBoundary;
  if(!(draw.flags & MarkerMask))
  {
    if(m_LastCmdListID != ResourceId())
      m_BakedCmdListInfo[m_LastCmdListID].drawCount++;
    else
      m_RootDrawcallID++;
  }

  if(hasEvents)
  {
    rdcarray<APIEvent> &srcEvents = m_LastCmdListID != ResourceId()
                                        ? m_BakedCmdListInfo[m_LastCmdListID].curEvents
                                        : m_RootEvents;

    draw.events = srcEvents;
    srcEvents.clear();
  }

  // should have at least the root drawcall here, push this drawcall
  // onto the back's children list.
  if(!GetDrawcallStack().empty())
  {
    D3D12DrawcallTreeNode node(draw);

    node.resourceUsage.swap(m_BakedCmdListInfo[m_LastCmdListID].resourceUsage);

    if(m_LastCmdListID != ResourceId() && addUsage)
      AddUsage(m_BakedCmdListInfo[m_LastCmdListID].state, node);

    for(const DrawcallDescription &child : draw.children)
      node.children.push_back(D3D12DrawcallTreeNode(child));
    GetDrawcallStack().back()->children.push_back(node);
  }
  else
    RDCERR(""Somehow lost drawcall stack!"");
}

void D3D12CommandData::InsertDrawsAndRefreshIDs(ResourceId cmd,
                                                rdcarray<D3D12DrawcallTreeNode> &cmdBufNodes)
{
  // assign new drawcall IDs
  for(size_t i = 0; i < cmdBufNodes.size(); i++)
  {
    if(cmdBufNodes[i].draw.flags & DrawFlags::PopMarker)
    {
      if(GetDrawcallStack().size() > 1)
        GetDrawcallStack().pop_back();

      // Skip - pop marker draws aren't processed otherwise, we just apply them to the drawcall
      // stack.
      continue;
    }

    D3D12DrawcallTreeNode n = cmdBufNodes[i];
    n.draw.eventId += m_RootEventID;
    n.draw.drawcallId += m_RootDrawcallID;

    for(APIEvent &ev : n.draw.events)
    {
      ev.eventId += m_RootEventID;
      m_Events.resize(ev.eventId + 1);
      m_Events[ev.eventId] = ev;
    }

    DrawcallUse use(m_Events.back().fileOffset, n.draw.eventId, cmd, cmdBufNodes[i].draw.eventId);

    // insert in sorted location
    auto drawit = std::lower_bound(m_DrawcallUses.begin(), m_DrawcallUses.end(), use);
    m_DrawcallUses.insert(drawit - m_DrawcallUses.begin(), use);

    RDCASSERT(n.children.empty());

    for(auto it = n.resourceUsage.begin(); it != n.resourceUsage.end(); ++it)
    {
      EventUsage u = it->second;
      u.eventId += m_RootEventID;
      m_ResourceUses[it->first].push_back(u);
    }

    GetDrawcallStack().back()->children.push_back(n);

    // if this is a push marker too, step down the drawcall stack
    if(cmdBufNodes[i].draw.flags & DrawFlags::PushMarker)
      GetDrawcallStack().push_back(&GetDrawcallStack().back()->children.back());
  }
}
",16299,True,2728.4120248842933,median
"/*
  Copyright (c) 2010-2016, Intel Corporation
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are
  met:

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of Intel Corporation nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.


   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS
   IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/** @file ispc.cpp
    @brief ispc global definitions
*/

#include ""ispc.h""
#include ""llvmutil.h""
#include ""module.h""
#include ""util.h""
#include <sstream>
#include <stdarg.h> /* va_list, va_start, va_arg, va_end */
#include <stdio.h>
#ifdef ISPC_IS_WINDOWS
#include <direct.h>
#include <windows.h>
#define strcasecmp stricmp
#if ISPC_LLVM_VERSION >= ISPC_LLVM_7_0
#include <intrin.h>
#endif
#else
#include <sys/types.h>
#include <unistd.h>
#endif
#if ISPC_LLVM_VERSION == ISPC_LLVM_3_2
#include <llvm/Instructions.h>
#include <llvm/LLVMContext.h>
#include <llvm/Module.h>
#else /* 3.3+ */
#include <llvm/IR/Instructions.h>
#include <llvm/IR/LLVMContext.h>
#include <llvm/IR/Module.h>
#endif
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_6 // LLVM 3.6+
#if ISPC_LLVM_VERSION >= ISPC_LLVM_6_0
#include <llvm/CodeGen/TargetLowering.h>
#include <llvm/CodeGen/TargetSubtargetInfo.h>
#else
#include <llvm/Target/TargetSubtargetInfo.h>
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_7 // LLVM 3.7+
#include <llvm/Target/TargetLowering.h>
#endif
#endif
#endif
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_5 // LLVM 3.5+
#include <llvm/IR/DIBuilder.h>
#include <llvm/IR/DebugInfo.h>
#else // LLVM 3.2, 3.3, 3.4
#include <llvm/DIBuilder.h>
#include <llvm/DebugInfo.h>
#endif
#if ISPC_LLVM_VERSION >= ISPC_LLVM_5_0 // LLVM 5.0+
#include <llvm/BinaryFormat/Dwarf.h>
#else // LLVM up to 4.x
#include <llvm/Support/Dwarf.h>
#endif
#include <llvm/Target/TargetMachine.h>
#include <llvm/Target/TargetOptions.h>
#if ISPC_LLVM_VERSION == ISPC_LLVM_3_2
#include <llvm/DataLayout.h>
#else // LLVM 3.3+
#include <llvm/IR/Attributes.h>
#include <llvm/IR/DataLayout.h>
#endif
#include <llvm/Support/CodeGen.h>
#include <llvm/Support/Host.h>
#include <llvm/Support/TargetRegistry.h>
#include <llvm/Support/TargetSelect.h>

Globals *g;
Module *m;

///////////////////////////////////////////////////////////////////////////
// Target

#if !defined(ISPC_IS_WINDOWS) && !defined(__arm__)
static void __cpuid(int info[4], int infoType) {
    __asm__ __volatile__(""cpuid"" : ""=a""(info[0]), ""=b""(info[1]), ""=c""(info[2]), ""=d""(info[3]) : ""0""(infoType));
}

/* Save %ebx in case it's the PIC register */
static void __cpuidex(int info[4], int level, int count) {
    __asm__ __volatile__(""xchg{l}\\t{%%}ebx, %1\\n\\t""
                         ""cpuid\\n\\t""
                         ""xchg{l}\\t{%%}ebx, %1\\n\\t""
                         : ""=a""(info[0]), ""=r""(info[1]), ""=c""(info[2]), ""=d""(info[3])
                         : ""0""(level), ""2""(count));
}
#endif // !ISPC_IS_WINDOWS && !__ARM__

#if !defined(__arm__)
static bool __os_has_avx_support() {
#if defined(ISPC_IS_WINDOWS)
    // Check if the OS will save the YMM registers
    unsigned long long xcrFeatureMask = _xgetbv(_XCR_XFEATURE_ENABLED_MASK);
    return (xcrFeatureMask & 6) == 6;
#else  // !defined(ISPC_IS_WINDOWS)
    // Check xgetbv; this uses a .byte sequence instead of the instruction
    // directly because older assemblers do not include support for xgetbv and
    // there is no easy way to conditionally compile based on the assembler used.
    int rEAX, rEDX;
    __asm__ __volatile__("".byte 0x0f, 0x01, 0xd0"" : ""=a""(rEAX), ""=d""(rEDX) : ""c""(0));
    return (rEAX & 6) == 6;
#endif // !defined(ISPC_IS_WINDOWS)
}

static bool __os_has_avx512_support() {
#if defined(ISPC_IS_WINDOWS)
    // Check if the OS saves the XMM, YMM and ZMM registers, i.e. it supports AVX2 and AVX512.
    // See section 2.1 of software.intel.com/sites/default/files/managed/0d/53/319433-022.pdf
    unsigned long long xcrFeatureMask = _xgetbv(_XCR_XFEATURE_ENABLED_MASK);
    return (xcrFeatureMask & 0xE6) == 0xE6;
#else  // !defined(ISPC_IS_WINDOWS)
    // Check xgetbv; this uses a .byte sequence instead of the instruction
    // directly because older assemblers do not include support for xgetbv and
    // there is no easy way to conditionally compile based on the assembler used.
    int rEAX, rEDX;
    __asm__ __volatile__("".byte 0x0f, 0x01, 0xd0"" : ""=a""(rEAX), ""=d""(rEDX) : ""c""(0));
    return (rEAX & 0xE6) == 0xE6;
#endif // !defined(ISPC_IS_WINDOWS)
}
#endif // !__arm__

static const char *lGetSystemISA() {
#ifdef __arm__
    return ""neon-i32x4"";
#else
    int info[4];
    __cpuid(info, 1);

    int info2[4];
    // Call cpuid with eax=7, ecx=0
    __cpuidex(info2, 7, 0);

    if ((info[2] & (1 << 27)) != 0 &&  // OSXSAVE
        (info2[1] & (1 << 5)) != 0 &&  // AVX2
        (info2[1] & (1 << 16)) != 0 && // AVX512 F
        __os_has_avx512_support()) {
        // We need to verify that AVX2 is also available,
        // as well as AVX512, because our targets are supposed
        // to use both.

        if ((info2[1] & (1 << 17)) != 0 && // AVX512 DQ
            (info2[1] & (1 << 28)) != 0 && // AVX512 CDI
            (info2[1] & (1 << 30)) != 0 && // AVX512 BW
            (info2[1] & (1 << 31)) != 0) { // AVX512 VL
            return ""avx512skx-i32x16"";
        } else if ((info2[1] & (1 << 26)) != 0 && // AVX512 PF
                   (info2[1] & (1 << 27)) != 0 && // AVX512 ER
                   (info2[1] & (1 << 28)) != 0) { // AVX512 CDI
            return ""avx512knl-i32x16"";
        }
        // If it's unknown AVX512 target, fall through and use AVX2
        // or whatever is available in the machine.
    }

    if ((info[2] & (1 << 27)) != 0 &&                           // OSXSAVE
        (info[2] & (1 << 28)) != 0 && __os_has_avx_support()) { // AVX
        // AVX1 for sure....
        // Ivy Bridge?
        if ((info[2] & (1 << 29)) != 0 && // F16C
            (info[2] & (1 << 30)) != 0) { // RDRAND
            // So far, so good.  AVX2?
            if ((info2[1] & (1 << 5)) != 0)
                return ""avx2-i32x8"";
            else
                return ""avx1.1-i32x8"";
        }
        // Regular AVX
        return ""avx1-i32x8"";
    } else if ((info[2] & (1 << 19)) != 0)
        return ""sse4-i32x4"";
    else if ((info[3] & (1 << 26)) != 0)
        return ""sse2-i32x4"";
    else {
        Error(SourcePos(), ""Unable to detect supported SSE/AVX ISA.  Exiting."");
        exit(1);
    }
#endif
}

typedef enum {
    // Special value, indicates that no CPU is present.
    CPU_None = 0,

    // 'Generic' CPU without any hardware SIMD capabilities.
    CPU_Generic = 1,

    // A generic 64-bit specific x86 processor model which tries to be good
    // for modern chips without enabling instruction set encodings past the
    // basic SSE2 and 64-bit ones
    CPU_x86_64,

    // Early Atom CPU. Supports SSSE3.
    CPU_Bonnell,

    // Generic Core2-like. Supports SSSE3. Isn`t quite compatible with Bonnell,
    // but for ISPC the difference is negligible; ISPC doesn`t make use of it.
    CPU_Core2,

    // Core2 Solo/Duo/Quad/Extreme. Supports SSE 4.1 (but not 4.2).
    CPU_Penryn,

    // Late Core2-like. Supports SSE 4.2 + POPCNT/LZCNT.
    CPU_Nehalem,

    // Sandy Bridge. Supports AVX 1.
    CPU_SandyBridge,

    // Ivy Bridge. Supports AVX 1 + RDRAND.
    CPU_IvyBridge,

    // Haswell. Supports AVX 2.
    CPU_Haswell,

#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_6 // LLVM 3.6+
    // Broadwell. Supports AVX 2 + ADX/RDSEED/SMAP.
    CPU_Broadwell,
#endif

#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_7 // LLVM 3.7+
    // Knights Landing - Xeon Phi.
    // Supports AVX-512F: All the key AVX-512 features: masking, broadcast... ;
    //          AVX-512CDI: Conflict Detection;
    //          AVX-512ERI & PRI: 28-bit precision RCP, RSQRT and EXP transcendentals,
    //                            new prefetch instructions.
    CPU_KNL,
#endif

#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_8 // LLVM 3.8+
    // Skylake Xeon.
    // Supports AVX-512F: All the key AVX-512 features: masking, broadcast... ;
    //          AVX-512CDI: Conflict Detection;
    //          AVX-512VL: Vector Length Orthogonality;
    //          AVX-512DQ: New HPC ISA (vs AVX512F);
    //          AVX-512BW: Byte and Word Support.
    CPU_SKX,
#endif

#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_4 // LLVM 3.4+
    // Late Atom-like design. Supports SSE 4.2 + POPCNT/LZCNT.
    CPU_Silvermont,
#endif

// FIXME: LLVM supports a ton of different ARM CPU variants--not just
// cortex-a9 and a15.  We should be able to handle any of them that also
// have NEON support.
#ifdef ISPC_ARM_ENABLED
    // ARM Cortex A15. Supports NEON VFPv4.
    CPU_CortexA15,

    // ARM Cortex A9. Supports NEON VFPv3.
    CPU_CortexA9,
#endif

#ifdef ISPC_NVPTX_ENABLED
    // NVidia CUDA-compatible SM-35 architecture.
    CPU_SM35,
#endif

    sizeofCPUtype
} CPUtype;

class AllCPUs {
  private:
    std::vector<std::vector<std::string>> names;
    std::vector<std::set<CPUtype>> compat;

    std::set<CPUtype> Set(int type, ...) {
        std::set<CPUtype> retn;
        va_list args;

        retn.insert((CPUtype)type);
        va_start(args, type);
        while ((type = va_arg(args, int)) != CPU_None)
            retn.insert((CPUtype)type);
        va_end(args);

        return retn;
    }

  public:
    AllCPUs() {
        names = std::vector<std::vector<std::string>>(sizeofCPUtype);
        compat = std::vector<std::set<CPUtype>>(sizeofCPUtype);

        names[CPU_None].push_back("""");

        names[CPU_Generic].push_back(""generic"");

        names[CPU_x86_64].push_back(""x86-64"");

        names[CPU_Bonnell].push_back(""atom"");
        names[CPU_Bonnell].push_back(""bonnell"");

        names[CPU_Core2].push_back(""core2"");

        names[CPU_Penryn].push_back(""penryn"");

#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_4 // LLVM 3.4+
        names[CPU_Silvermont].push_back(""slm"");
        names[CPU_Silvermont].push_back(""silvermont"");
#endif

        names[CPU_Nehalem].push_back(""corei7"");
        names[CPU_Nehalem].push_back(""nehalem"");

        names[CPU_SandyBridge].push_back(""corei7-avx"");
        names[CPU_SandyBridge].push_back(""sandybridge"");

        names[CPU_IvyBridge].push_back(""core-avx-i"");
        names[CPU_IvyBridge].push_back(""ivybridge"");

        names[CPU_Haswell].push_back(""core-avx2"");
        names[CPU_Haswell].push_back(""haswell"");

#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_6 // LLVM 3.6+
        names[CPU_Broadwell].push_back(""broadwell"");
#endif

#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_7 // LLVM 3.7+
        names[CPU_KNL].push_back(""knl"");
#endif

#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_8 // LLVM 3.8+
        names[CPU_SKX].push_back(""skx"");
#endif

#ifdef ISPC_ARM_ENABLED
        names[CPU_CortexA15].push_back(""cortex-a15"");

        names[CPU_CortexA9].push_back(""cortex-a9"");
#endif

#ifdef ISPC_NVPTX_ENABLED
        names[CPU_SM35].push_back(""sm_35"");
#endif

#if ISPC_LLVM_VERSION <= ISPC_LLVM_3_3 // LLVM 3.2 or 3.3
#define CPU_Silvermont CPU_Nehalem
#else /* LLVM 3.4+ */
        compat[CPU_Silvermont] =
            Set(CPU_Generic, CPU_x86_64, CPU_Bonnell, CPU_Penryn, CPU_Core2, CPU_Nehalem, CPU_Silvermont, CPU_None);
#endif

#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_7 // LLVM 3.7+
        compat[CPU_KNL] = Set(CPU_KNL, CPU_Generic, CPU_x86_64, CPU_Bonnell, CPU_Penryn, CPU_Core2, CPU_Nehalem,
                              CPU_Silvermont, CPU_SandyBridge, CPU_IvyBridge, CPU_Haswell, CPU_Broadwell, CPU_None);
#endif

#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_8 // LLVM 3.8+
        compat[CPU_SKX] = Set(CPU_SKX, CPU_x86_64, CPU_Bonnell, CPU_Penryn, CPU_Core2, CPU_Nehalem, CPU_Silvermont,
                              CPU_SandyBridge, CPU_IvyBridge, CPU_Haswell, CPU_Broadwell, CPU_None);
#endif

#if ISPC_LLVM_VERSION <= ISPC_LLVM_3_5 // LLVM 3.2, 3.3, 3.4 or 3.5
#define CPU_Broadwell CPU_Haswell
#else /* LLVM 3.6+ */
        compat[CPU_Broadwell] =
            Set(CPU_Generic, CPU_x86_64, CPU_Bonnell, CPU_Penryn, CPU_Core2, CPU_Nehalem, CPU_Silvermont,
                CPU_SandyBridge, CPU_IvyBridge, CPU_Haswell, CPU_Broadwell, CPU_None);
#endif
        compat[CPU_Haswell] = Set(CPU_Generic, CPU_x86_64, CPU_Bonnell, CPU_Penryn, CPU_Core2, CPU_Nehalem,
                                  CPU_Silvermont, CPU_SandyBridge, CPU_IvyBridge, CPU_Haswell, CPU_Broadwell, CPU_None);
        compat[CPU_IvyBridge] = Set(CPU_Generic, CPU_x86_64, CPU_Bonnell, CPU_Penryn, CPU_Core2, CPU_Nehalem,
                                    CPU_Silvermont, CPU_SandyBridge, CPU_IvyBridge, CPU_None);
        compat[CPU_SandyBridge] = Set(CPU_Generic, CPU_x86_64, CPU_Bonnell, CPU_Penryn, CPU_Core2, CPU_Nehalem,
                                      CPU_Silvermont, CPU_SandyBridge, CPU_None);
        compat[CPU_Nehalem] =
            Set(CPU_Generic, CPU_x86_64, CPU_Bonnell, CPU_Penryn, CPU_Core2, CPU_Nehalem, CPU_Silvermont, CPU_None);
        compat[CPU_Penryn] =
            Set(CPU_Generic, CPU_x86_64, CPU_Bonnell, CPU_Penryn, CPU_Core2, CPU_Nehalem, CPU_Silvermont, CPU_None);
        compat[CPU_Core2] = Set(CPU_Generic, CPU_x86_64, CPU_Bonnell, CPU_Core2, CPU_None);
        compat[CPU_Bonnell] = Set(CPU_Generic, CPU_x86_64, CPU_Bonnell, CPU_Core2, CPU_None);
        compat[CPU_Generic] = Set(CPU_Generic, CPU_None);

        compat[CPU_x86_64] = Set(CPU_Generic, CPU_x86_64, CPU_None);

#ifdef ISPC_ARM_ENABLED
        compat[CPU_CortexA15] = Set(CPU_Generic, CPU_CortexA9, CPU_CortexA15, CPU_None);
        compat[CPU_CortexA9] = Set(CPU_Generic, CPU_CortexA9, CPU_None);
#endif

#ifdef ISPC_NVPTX_ENABLED
        compat[CPU_SM35] = Set(CPU_Generic, CPU_SM35, CPU_None);
#endif
    }

    std::string HumanReadableListOfNames() {
        std::stringstream CPUs;
        for (int i = CPU_Generic; i < sizeofCPUtype; i++) {
            CPUs << names[i][0];
            if (names[i].size() > 1) {
                CPUs << "" (synonyms: "" << names[i][1];
                for (int j = 2, je = names[i].size(); j < je; j++)
                    CPUs << "", "" << names[i][j];
                CPUs << "")"";
            }
            if (i < sizeofCPUtype - 1)
                CPUs << "", "";
        }
        return CPUs.str();
    }

    std::string &GetDefaultNameFromType(CPUtype type) {
        Assert((type >= CPU_None) && (type < sizeofCPUtype));
        return names[type][0];
    }

    CPUtype GetTypeFromName(std::string name) {
        CPUtype retn = CPU_None;

        for (int i = 1; (retn == CPU_None) && (i < sizeofCPUtype); i++)
            for (int j = 0, je = names[i].size(); (retn == CPU_None) && (j < je); j++)
                if (!name.compare(names[i][j]))
                    retn = (CPUtype)i;
        return retn;
    }

    bool BackwardCompatible(CPUtype what, CPUtype with) {
        Assert((what > CPU_None) && (what < sizeofCPUtype));
        Assert((with > CPU_None) && (with < sizeofCPUtype));
        return compat[what].find(with) != compat[what].end();
    }
};

Target::Target(const char *arch, const char *cpu, const char *isa, bool pic, bool printTarget,
               std::string genericAsSmth)
    : m_target(NULL), m_targetMachine(NULL), m_dataLayout(NULL), m_valid(false), m_isa(SSE2),
      m_treatGenericAsSmth(genericAsSmth), m_arch(""""), m_is32Bit(true), m_cpu(""""), m_attributes(""""),
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_3
      m_tf_attributes(NULL),
#endif
      m_nativeVectorWidth(-1), m_nativeVectorAlignment(-1), m_dataTypeWidth(-1), m_vectorWidth(-1), m_generatePIC(pic),
      m_maskingIsFree(false), m_maskBitCount(-1), m_hasHalf(false), m_hasRand(false), m_hasGather(false),
      m_hasScatter(false), m_hasTranscendentals(false), m_hasTrigonometry(false), m_hasRsqrtd(false), m_hasRcpd(false),
      m_hasVecPrefetch(false) {
    CPUtype CPUID = CPU_None, CPUfromISA = CPU_None;
    AllCPUs a;

    if (cpu) {
        CPUID = a.GetTypeFromName(cpu);
        if (CPUID == CPU_None) {
            Error(SourcePos(),
                  ""Error: CPU type \\""%s\\"" unknown. Supported""
                  "" CPUs: %s."",
                  cpu, a.HumanReadableListOfNames().c_str());
            return;
        }
    }

    if (isa == NULL) {
        // If a CPU was specified explicitly, try to pick the best
        // possible ISA based on that.
        switch (CPUID) {
        case CPU_None:
            // No CPU and no ISA, so use system info to figure out
            // what this CPU supports.
            isa = lGetSystemISA();
            Warning(SourcePos(),
                    ""No --target specified on command-line.""
                    "" Using default system target \\""%s\\""."",
                    isa);
            break;

        case CPU_Generic:
            isa = ""generic-1"";
            break;

#ifdef ISPC_NVPTX_ENABLED
        case CPU_SM35:
            isa = ""nvptx"";
            break;
#endif

#ifdef ISPC_ARM_ENABLED
        case CPU_CortexA9:
        case CPU_CortexA15:
            isa = ""neon-i32x4"";
            break;
#endif

#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_7 // LLVM 3.7+
        case CPU_KNL:
            isa = ""avx512knl-i32x16"";
            break;
#endif

#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_8 // LLVM 3.8+
        case CPU_SKX:
            isa = ""avx512skx-i32x16"";
            break;
#endif

#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_6
        case CPU_Broadwell:
#endif
        case CPU_Haswell:
            isa = ""avx2-i32x8"";
            break;

        case CPU_IvyBridge:
            isa = ""avx1.1-i32x8"";
            break;

        case CPU_SandyBridge:
            isa = ""avx1-i32x8"";
            break;

        // Penryn is here because ISPC does not use SSE 4.2
        case CPU_Penryn:
        case CPU_Nehalem:
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_4
        case CPU_Silvermont:
#endif
            isa = ""sse4-i32x4"";
            break;

        default:
            isa = ""sse2-i32x4"";
            break;
        }
        if (CPUID != CPU_None)
            Warning(SourcePos(),
                    ""No --target specified on command-line.""
                    "" Using ISA \\""%s\\"" based on specified CPU \\""%s\\""."",
                    isa, cpu);
    }

    if (!strcasecmp(isa, ""host"")) {
        isa = lGetSystemISA();
    }

    if (arch == NULL) {
#ifdef ISPC_ARM_ENABLED
        if (!strncmp(isa, ""neon"", 4))
            arch = ""arm"";
        else
#endif
#ifdef ISPC_NVPTX_ENABLED
            if (!strncmp(isa, ""nvptx"", 5))
            arch = ""nvptx64"";
        else
#endif /* ISPC_NVPTX_ENABLED */
            arch = ""x86-64"";
    }

    // Define arch alias
    if (std::string(arch) == ""x86_64"")
        arch = ""x86-64"";

    bool error = false;

    // Make sure the target architecture is a known one; print an error
    // with the valid ones otherwise.
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_7 // LLVM 3.7+
    for (llvm::TargetRegistry::iterator iter = llvm::TargetRegistry::targets().begin();
         iter != llvm::TargetRegistry::targets().end(); ++iter) {
#else
    for (llvm::TargetRegistry::iterator iter = llvm::TargetRegistry::begin(); iter != llvm::TargetRegistry::end();
         ++iter) {
#endif
        if (std::string(arch) == iter->getName()) {
            this->m_target = &*iter;
            break;
        }
    }
    if (this->m_target == NULL) {
        fprintf(stderr, ""Invalid architecture \\""%s\\""\\nOptions: "", arch);
        llvm::TargetRegistry::iterator iter;
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_7 // LLVM 3.7+
        for (iter = llvm::TargetRegistry::targets().begin(); iter != llvm::TargetRegistry::targets().end(); ++iter)
#else
        for (iter = llvm::TargetRegistry::begin(); iter != llvm::TargetRegistry::end(); ++iter)
#endif
            fprintf(stderr, ""%s "", iter->getName());
        fprintf(stderr, ""\\n"");
        error = true;
    } else {
        this->m_arch = arch;
    }

    // Check default LLVM generated targets
    if (!strcasecmp(isa, ""sse2"") || !strcasecmp(isa, ""sse2-i32x4"")) {
        this->m_isa = Target::SSE2;
        this->m_nativeVectorWidth = 4;
        this->m_nativeVectorAlignment = 16;
        this->m_dataTypeWidth = 32;
        this->m_vectorWidth = 4;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 32;
        CPUfromISA = CPU_x86_64;
    } else if (!strcasecmp(isa, ""sse2-x2"") || !strcasecmp(isa, ""sse2-i32x8"")) {
        this->m_isa = Target::SSE2;
        this->m_nativeVectorWidth = 4;
        this->m_nativeVectorAlignment = 16;
        this->m_dataTypeWidth = 32;
        this->m_vectorWidth = 8;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 32;
        CPUfromISA = CPU_Core2;
    } else if (!strcasecmp(isa, ""sse4"") || !strcasecmp(isa, ""sse4-i32x4"")) {
        this->m_isa = Target::SSE4;
        this->m_nativeVectorWidth = 4;
        this->m_nativeVectorAlignment = 16;
        this->m_dataTypeWidth = 32;
        this->m_vectorWidth = 4;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 32;
        CPUfromISA = CPU_Nehalem;
    } else if (!strcasecmp(isa, ""sse4x2"") || !strcasecmp(isa, ""sse4-x2"") || !strcasecmp(isa, ""sse4-i32x8"")) {
        this->m_isa = Target::SSE4;
        this->m_nativeVectorWidth = 4;
        this->m_nativeVectorAlignment = 16;
        this->m_dataTypeWidth = 32;
        this->m_vectorWidth = 8;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 32;
        CPUfromISA = CPU_Nehalem;
    } else if (!strcasecmp(isa, ""sse4-i8x16"")) {
        this->m_isa = Target::SSE4;
        this->m_nativeVectorWidth = 16;
        this->m_nativeVectorAlignment = 16;
        this->m_dataTypeWidth = 8;
        this->m_vectorWidth = 16;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 8;
        CPUfromISA = CPU_Nehalem;
    } else if (!strcasecmp(isa, ""sse4-i16x8"")) {
        this->m_isa = Target::SSE4;
        this->m_nativeVectorWidth = 8;
        this->m_nativeVectorAlignment = 16;
        this->m_dataTypeWidth = 16;
        this->m_vectorWidth = 8;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 16;
        CPUfromISA = CPU_Nehalem;
    } else if (!strcasecmp(isa, ""generic-4"") || !strcasecmp(isa, ""generic-x4"")) {
        this->m_isa = Target::GENERIC;
        this->m_nativeVectorWidth = 4;
        this->m_nativeVectorAlignment = 16;
        this->m_vectorWidth = 4;
        this->m_maskingIsFree = true;
        this->m_maskBitCount = 1;
        this->m_hasHalf = true;
        this->m_hasTranscendentals = true;
        this->m_hasTrigonometry = true;
        this->m_hasGather = this->m_hasScatter = true;
        this->m_hasRsqrtd = this->m_hasRcpd = true;
        CPUfromISA = CPU_Generic;
    } else if (!strcasecmp(isa, ""generic-8"") || !strcasecmp(isa, ""generic-x8"")) {
        this->m_isa = Target::GENERIC;
        this->m_nativeVectorWidth = 8;
        this->m_nativeVectorAlignment = 32;
        this->m_vectorWidth = 8;
        this->m_maskingIsFree = true;
        this->m_maskBitCount = 1;
        this->m_hasHalf = true;
        this->m_hasTranscendentals = true;
        this->m_hasTrigonometry = true;
        this->m_hasGather = this->m_hasScatter = true;
        this->m_hasRsqrtd = this->m_hasRcpd = true;
        CPUfromISA = CPU_Generic;
    } else if (!strcasecmp(isa, ""generic-16"") || !strcasecmp(isa, ""generic-x16"") ||
               // We treat *-generic-16 as generic-16, but with special name mangling
               strstr(isa, ""-generic-16"") || strstr(isa, ""-generic-x16"")) {
        this->m_isa = Target::GENERIC;
        if (strstr(isa, ""-generic-16"") || strstr(isa, ""-generic-x16"")) {
            // It is used for appropriate name mangling and dispatch function during multitarget compilation
            this->m_treatGenericAsSmth = isa;
            // We need to create appropriate name for mangling.
            // Remove ""-x16"" or ""-16"" and replace ""-"" with ""_"".
            this->m_treatGenericAsSmth =
                this->m_treatGenericAsSmth.substr(0, this->m_treatGenericAsSmth.find_last_of(""-""));
            std::replace(this->m_treatGenericAsSmth.begin(), this->m_treatGenericAsSmth.end(), '-', '_');
        }
        this->m_nativeVectorWidth = 16;
        this->m_nativeVectorAlignment = 64;
        this->m_vectorWidth = 16;
        this->m_maskingIsFree = true;
        this->m_maskBitCount = 1;
        this->m_hasHalf = true;
        this->m_hasTranscendentals = true;
        // It's set to false, because stdlib implementation of math functions
        // is faster on MIC, than ""native"" implementation provided by the
        // icc compiler.
        this->m_hasTrigonometry = false;
        this->m_hasGather = this->m_hasScatter = true;
        this->m_hasRsqrtd = this->m_hasRcpd = true;
        // It's set to true, because MIC has hardware vector prefetch instruction
        this->m_hasVecPrefetch = true;
        CPUfromISA = CPU_Generic;
    } else if (!strcasecmp(isa, ""generic-32"") || !strcasecmp(isa, ""generic-x32"")) {
        this->m_isa = Target::GENERIC;
        this->m_nativeVectorWidth = 32;
        this->m_nativeVectorAlignment = 64;
        this->m_vectorWidth = 32;
        this->m_maskingIsFree = true;
        this->m_maskBitCount = 1;
        this->m_hasHalf = true;
        this->m_hasTranscendentals = true;
        this->m_hasTrigonometry = true;
        this->m_hasGather = this->m_hasScatter = true;
        this->m_hasRsqrtd = this->m_hasRcpd = true;
        CPUfromISA = CPU_Generic;
    } else if (!strcasecmp(isa, ""generic-64"") || !strcasecmp(isa, ""generic-x64"")) {
        this->m_isa = Target::GENERIC;
        this->m_nativeVectorWidth = 64;
        this->m_nativeVectorAlignment = 64;
        this->m_vectorWidth = 64;
        this->m_maskingIsFree = true;
        this->m_maskBitCount = 1;
        this->m_hasHalf = true;
        this->m_hasTranscendentals = true;
        this->m_hasTrigonometry = true;
        this->m_hasGather = this->m_hasScatter = true;
        this->m_hasRsqrtd = this->m_hasRcpd = true;
        CPUfromISA = CPU_Generic;
    } else if (!strcasecmp(isa, ""generic-1"") || !strcasecmp(isa, ""generic-x1"")) {
        this->m_isa = Target::GENERIC;
        this->m_nativeVectorWidth = 1;
        this->m_nativeVectorAlignment = 16;
        this->m_vectorWidth = 1;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 32;
        CPUfromISA = CPU_Generic;
    } else if (!strcasecmp(isa, ""avx1-i32x4"")) {
        this->m_isa = Target::AVX;
        this->m_nativeVectorWidth = 8;
        this->m_nativeVectorAlignment = 32;
        this->m_dataTypeWidth = 32;
        this->m_vectorWidth = 4;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 32;
        CPUfromISA = CPU_SandyBridge;
    } else if (!strcasecmp(isa, ""avx"") || !strcasecmp(isa, ""avx1"") || !strcasecmp(isa, ""avx1-i32x8"")) {
        this->m_isa = Target::AVX;
        this->m_nativeVectorWidth = 8;
        this->m_nativeVectorAlignment = 32;
        this->m_dataTypeWidth = 32;
        this->m_vectorWidth = 8;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 32;
        CPUfromISA = CPU_SandyBridge;
    } else if (!strcasecmp(isa, ""avx-i64x4"") || !strcasecmp(isa, ""avx1-i64x4"")) {
        this->m_isa = Target::AVX;
        this->m_nativeVectorWidth = 8; /* native vector width in terms of floats */
        this->m_nativeVectorAlignment = 32;
        this->m_dataTypeWidth = 64;
        this->m_vectorWidth = 4;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 64;
        CPUfromISA = CPU_SandyBridge;
    } else if (!strcasecmp(isa, ""avx-x2"") || !strcasecmp(isa, ""avx1-x2"") || !strcasecmp(isa, ""avx1-i32x16"")) {
        this->m_isa = Target::AVX;
        this->m_nativeVectorWidth = 8;
        this->m_nativeVectorAlignment = 32;
        this->m_dataTypeWidth = 32;
        this->m_vectorWidth = 16;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 32;
        CPUfromISA = CPU_SandyBridge;
    } else if (!strcasecmp(isa, ""avx1.1"") || !strcasecmp(isa, ""avx1.1-i32x8"")) {
        this->m_isa = Target::AVX11;
        this->m_nativeVectorWidth = 8;
        this->m_nativeVectorAlignment = 32;
        this->m_dataTypeWidth = 32;
        this->m_vectorWidth = 8;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 32;
        this->m_hasHalf = true;
        this->m_hasRand = true;
        CPUfromISA = CPU_IvyBridge;
    } else if (!strcasecmp(isa, ""avx1.1-x2"") || !strcasecmp(isa, ""avx1.1-i32x16"")) {
        this->m_isa = Target::AVX11;
        this->m_nativeVectorWidth = 8;
        this->m_nativeVectorAlignment = 32;
        this->m_dataTypeWidth = 32;
        this->m_vectorWidth = 16;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 32;
        this->m_hasHalf = true;
        this->m_hasRand = true;
        CPUfromISA = CPU_IvyBridge;
    } else if (!strcasecmp(isa, ""avx1.1-i64x4"")) {
        this->m_isa = Target::AVX11;
        this->m_nativeVectorWidth = 8; /* native vector width in terms of floats */
        this->m_nativeVectorAlignment = 32;
        this->m_dataTypeWidth = 64;
        this->m_vectorWidth = 4;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 64;
        this->m_hasHalf = true;
        this->m_hasRand = true;
        CPUfromISA = CPU_IvyBridge;
    } else if (!strcasecmp(isa, ""avx2"") || !strcasecmp(isa, ""avx2-i32x8"")) {
        this->m_isa = Target::AVX2;
        this->m_nativeVectorWidth = 8;
        this->m_nativeVectorAlignment = 32;
        this->m_dataTypeWidth = 32;
        this->m_vectorWidth = 8;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 32;
        this->m_hasHalf = true;
        this->m_hasRand = true;
        this->m_hasGather = true;
        CPUfromISA = CPU_Haswell;
    } else if (!strcasecmp(isa, ""avx2-x2"") || !strcasecmp(isa, ""avx2-i32x16"")) {
        this->m_isa = Target::AVX2;
        this->m_nativeVectorWidth = 16;
        this->m_nativeVectorAlignment = 32;
        this->m_dataTypeWidth = 32;
        this->m_vectorWidth = 16;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 32;
        this->m_hasHalf = true;
        this->m_hasRand = true;
        this->m_hasGather = true;
        CPUfromISA = CPU_Haswell;
    } else if (!strcasecmp(isa, ""avx2-i64x4"")) {
        this->m_isa = Target::AVX2;
        this->m_nativeVectorWidth = 8; /* native vector width in terms of floats */
        this->m_nativeVectorAlignment = 32;
        this->m_dataTypeWidth = 64;
        this->m_vectorWidth = 4;
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 64;
        this->m_hasHalf = true;
        this->m_hasRand = true;
        this->m_hasGather = true;
        CPUfromISA = CPU_Haswell;
    }
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_7 // LLVM 3.7+
    else if (!strcasecmp(isa, ""avx512knl-i32x16"")) {
        this->m_isa = Target::KNL_AVX512;
        this->m_nativeVectorWidth = 16;
        this->m_nativeVectorAlignment = 64;
        this->m_dataTypeWidth = 32;
        this->m_vectorWidth = 16;
        this->m_maskingIsFree = true;
        this->m_maskBitCount = 8;
        this->m_hasHalf = true;
        this->m_hasRand = true;
        this->m_hasGather = this->m_hasScatter = true;
        this->m_hasTranscendentals = false;
        // For MIC it is set to true due to performance reasons. The option should be tested.
        this->m_hasTrigonometry = false;
        this->m_hasRsqrtd = this->m_hasRcpd = false;
        this->m_hasVecPrefetch = false;
        CPUfromISA = CPU_KNL;
    }
#endif
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_8 // LLVM 3.8+
    else if (!strcasecmp(isa, ""avx512skx-i32x16"")) {
        this->m_isa = Target::SKX_AVX512;
        this->m_nativeVectorWidth = 16;
        this->m_nativeVectorAlignment = 64;
        this->m_dataTypeWidth = 32;
        this->m_vectorWidth = 16;
        this->m_maskingIsFree = true;
        this->m_maskBitCount = 8;
        this->m_hasHalf = true;
        this->m_hasRand = true;
        this->m_hasGather = this->m_hasScatter = true;
        this->m_hasTranscendentals = false;
        // For MIC it is set to true due to performance reasons. The option should be tested.
        this->m_hasTrigonometry = false;
        this->m_hasRsqrtd = this->m_hasRcpd = false;
        this->m_hasVecPrefetch = false;
        CPUfromISA = CPU_SKX;
    }
#endif
#ifdef ISPC_ARM_ENABLED
    else if (!strcasecmp(isa, ""neon-i8x16"")) {
        this->m_isa = Target::NEON8;
        this->m_nativeVectorWidth = 16;
        this->m_nativeVectorAlignment = 16;
        this->m_dataTypeWidth = 8;
        this->m_vectorWidth = 16;
        this->m_attributes = ""+neon,+fp16"";
        this->m_hasHalf = true; // ??
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 8;
    } else if (!strcasecmp(isa, ""neon-i16x8"")) {
        this->m_isa = Target::NEON16;
        this->m_nativeVectorWidth = 8;
        this->m_nativeVectorAlignment = 16;
        this->m_dataTypeWidth = 16;
        this->m_vectorWidth = 8;
        this->m_attributes = ""+neon,+fp16"";
        this->m_hasHalf = true; // ??
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 16;
    } else if (!strcasecmp(isa, ""neon"") || !strcasecmp(isa, ""neon-i32x4"")) {
        this->m_isa = Target::NEON32;
        this->m_nativeVectorWidth = 4;
        this->m_nativeVectorAlignment = 16;
        this->m_dataTypeWidth = 32;
        this->m_vectorWidth = 4;
        this->m_attributes = ""+neon,+fp16"";
        this->m_hasHalf = true; // ??
        this->m_maskingIsFree = false;
        this->m_maskBitCount = 32;
    }
#endif
#ifdef ISPC_NVPTX_ENABLED
    else if (!strcasecmp(isa, ""nvptx"")) {
        this->m_isa = Target::NVPTX;
        this->m_cpu = ""sm_35"";
        this->m_nativeVectorWidth = 32;
        this->m_nativeVectorAlignment = 32;
        this->m_vectorWidth = 1;
        this->m_hasHalf = true;
        this->m_maskingIsFree = true;
        this->m_maskBitCount = 1;
        this->m_hasTranscendentals = true;
        this->m_hasTrigonometry = true;
        this->m_hasGather = this->m_hasScatter = false;
        CPUfromISA = CPU_SM35;
    }
#endif /* ISPC_NVPTX_ENABLED */
    else {
        Error(SourcePos(), ""Target \\""%s\\"" is unknown.  Choices are: %s."", isa, SupportedTargets());
        error = true;
    }

#if defined(ISPC_ARM_ENABLED) && !defined(__arm__)
    if ((CPUID == CPU_None) && !strncmp(isa, ""neon"", 4))
        CPUID = CPU_CortexA9;
#endif

    if (CPUID == CPU_None) {
#ifndef ISPC_ARM_ENABLED
        if (isa == NULL) {
#endif
            std::string hostCPU = llvm::sys::getHostCPUName();
            if (hostCPU.size() > 0)
                cpu = strdup(hostCPU.c_str());
            else {
                Warning(SourcePos(), ""Unable to determine host CPU!\\n"");
                cpu = a.GetDefaultNameFromType(CPU_Generic).c_str();
            }
#ifndef ISPC_ARM_ENABLED
        } else {
            cpu = a.GetDefaultNameFromType(CPUfromISA).c_str();
        }
#endif
    } else {
        if ((CPUfromISA != CPU_None) && !a.BackwardCompatible(CPUID, CPUfromISA)) {
            Error(SourcePos(),
                  ""The requested CPU is incompatible""
                  "" with the CPU %s needs: %s vs. %s!\\n"",
                  isa, cpu, a.GetDefaultNameFromType(CPUfromISA).c_str());
            return;
        }
        cpu = a.GetDefaultNameFromType(CPUID).c_str();
    }
    this->m_cpu = cpu;

    if (!error) {
        // Create TargetMachine
        std::string triple = GetTripleString();

#if ISPC_LLVM_VERSION <= ISPC_LLVM_3_8
        llvm::Reloc::Model relocModel = m_generatePIC ? llvm::Reloc::PIC_ : llvm::Reloc::Default;
#else
        llvm::Optional<llvm::Reloc::Model> relocModel;
        if (m_generatePIC) {
            relocModel = llvm::Reloc::PIC_;
        }
#endif
        std::string featuresString = m_attributes;
        llvm::TargetOptions options;
#ifdef ISPC_ARM_ENABLED
        if (m_isa == Target::NEON8 || m_isa == Target::NEON16 || m_isa == Target::NEON32)
            options.FloatABIType = llvm::FloatABI::Hard;
#endif
        if (g->opt.disableFMA == false)
            options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
#if ISPC_LLVM_VERSION <= ISPC_LLVM_3_6
        if (g->NoOmitFramePointer)
            options.NoFramePointerElim = true;
#ifdef ISPC_IS_WINDOWS
        if (strcmp(""x86"", arch) == 0) {
            // Workaround for issue #503 (LLVM issue 14646).
            // It's Win32 specific.
            options.NoFramePointerElim = true;
        }
#endif
#endif
        m_targetMachine = m_target->createTargetMachine(triple, m_cpu, featuresString, options, relocModel);
        Assert(m_targetMachine != NULL);

        // Set Optimization level for llvm codegen based on Optimization level
        // requested by user via ISPC Optimization Flag. Mapping is :
        // ISPC O0 -> Codegen O0
        // ISPC O1,O2,O3,default -> Codegen O3
        llvm::CodeGenOpt::Level cOptLevel = llvm::CodeGenOpt::Level::Aggressive;
        switch (g->codegenOptLevel) {
        case Globals::CodegenOptLevel::None:
            cOptLevel = llvm::CodeGenOpt::Level::None;
            break;

        case Globals::CodegenOptLevel::Aggressive:
            cOptLevel = llvm::CodeGenOpt::Level::Aggressive;
            break;
        }
        m_targetMachine->setOptLevel(cOptLevel);

#if ISPC_LLVM_VERSION <= ISPC_LLVM_3_6
        m_targetMachine->setAsmVerbosityDefault(true);
#else /* LLVM 3.7+ */
        m_targetMachine->Options.MCOptions.AsmVerbose = true;
#endif

#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_5
        // Change default version of generated DWARF.
        if (g->generateDWARFVersion != 0) {
            m_targetMachine->Options.MCOptions.DwarfVersion = g->generateDWARFVersion;
        }
#endif

        // Initialize TargetData/DataLayout in 3 steps.
        // 1. Get default data layout first
        std::string dl_string;
#if ISPC_LLVM_VERSION == ISPC_LLVM_3_6
        dl_string = m_targetMachine->getSubtargetImpl()->getDataLayout()->getStringRepresentation();
#elif ISPC_LLVM_VERSION >= ISPC_LLVM_3_8 // LLVM 3.8+
        dl_string = m_targetMachine->createDataLayout().getStringRepresentation();
#else                                    // LLVM 3.5- or LLVM 3.7
    dl_string = m_targetMachine->getDataLayout()->getStringRepresentation();
#endif
        // 2. Adjust for generic
        if (m_isa == Target::GENERIC) {
            // <16 x i1> vectors only need 16 bit / 2 byte alignment, so add
            // that to the regular datalayout string for IA..
            // For generic-4 target we need to treat <4 x i1> as 128 bit value
            // in terms of required memory storage and alignment, as this is
            // translated to __m128 type.
            dl_string = ""e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-""
                        ""i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-""
                        ""f80:128:128-n8:16:32:64-S128-v16:16:16-v32:32:32-v4:128:128"";
        }
#ifdef ISPC_NVPTX_ENABLED
        else if (m_isa == Target::NVPTX) {
            dl_string = ""e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v32:32:""
                        ""32-v64:64:64-v128:128:128-n16:32:64"";
        }
#endif

        // 3. Finally set member data
        m_dataLayout = new llvm::DataLayout(dl_string);

        // Set is32Bit
        // This indicates if we are compiling for 32 bit platform
        // and can assume 32 bit runtime.
        // FIXME: all generic targets are handled as 64 bit, which is incorrect.

        this->m_is32Bit = (getDataLayout()->getPointerSize() == 4);

#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_3
        // This is LLVM 3.3+ feature.
        // Initialize target-specific ""target-feature"" attribute.
        if (!m_attributes.empty()) {
            llvm::AttrBuilder attrBuilder;
#ifdef ISPC_NVPTX_ENABLED
            if (m_isa != Target::NVPTX)
#endif
                attrBuilder.addAttribute(""target-cpu"", this->m_cpu);
            attrBuilder.addAttribute(""target-features"", this->m_attributes);
#if ISPC_LLVM_VERSION <= ISPC_LLVM_4_0
            this->m_tf_attributes = new llvm::AttributeSet(
                llvm::AttributeSet::get(*g->ctx, llvm::AttributeSet::FunctionIndex, attrBuilder));
#else // LLVM 5.0+
            this->m_tf_attributes = new llvm::AttrBuilder(attrBuilder);
#endif
        }
#endif

        Assert(this->m_vectorWidth <= ISPC_MAX_NVEC);
    }

    m_valid = !error;

    if (printTarget) {
        printf(""Target Triple: %s\\n"", m_targetMachine->getTargetTriple().str().c_str());
        printf(""Target CPU: %s\\n"", m_targetMachine->getTargetCPU().str().c_str());
        printf(""Target Feature String: %s\\n"", m_targetMachine->getTargetFeatureString().str().c_str());
    }

    return;
}

std::string Target::SupportedCPUs() {
    AllCPUs a;
    return a.HumanReadableListOfNames();
}

const char *Target::SupportedArchs() {
    return
#ifdef ISPC_ARM_ENABLED
        ""arm, ""
#endif
        ""x86, x86-64"";
}

const char *Target::SupportedTargets() {
    return ""host, sse2-i32x4, sse2-i32x8, ""
           ""sse4-i32x4, sse4-i32x8, sse4-i16x8, sse4-i8x16, ""
           ""avx1-i32x4, ""
           ""avx1-i32x8, avx1-i32x16, avx1-i64x4, ""
           ""avx1.1-i32x8, avx1.1-i32x16, avx1.1-i64x4, ""
           ""avx2-i32x8, avx2-i32x16, avx2-i64x4, ""
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_7 // LLVM 3.7+
           ""avx512knl-i32x16, ""
#endif
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_8 // LLVM 3.8+
           ""avx512skx-i32x16, ""
#endif
           ""generic-x1, generic-x4, generic-x8, generic-x16, ""
           ""generic-x32, generic-x64, *-generic-x16""
#ifdef ISPC_ARM_ENABLED
           "", neon-i8x16, neon-i16x8, neon-i32x4""
#endif
#ifdef ISPC_NVPTX_ENABLED
           "", nvptx""
#endif
        ;
}

std::string Target::GetTripleString() const {
    llvm::Triple triple;
#ifdef ISPC_ARM_ENABLED
    if (m_arch == ""arm"") {
        triple.setTriple(""armv7-eabi"");
    } else
#endif
    {
        // Start with the host triple as the default
        triple.setTriple(llvm::sys::getDefaultTargetTriple());

        // And override the arch in the host triple based on what the user
        // specified.  Here we need to deal with the fact that LLVM uses one
        // naming convention for targets TargetRegistry, but wants some
        // slightly different ones for the triple.  TODO: is there a way to
        // have it do this remapping, which would presumably be a bit less
        // error prone?
        if (m_arch == ""x86"")
            triple.setArchName(""i386"");
        else if (m_arch == ""x86-64"")
            triple.setArchName(""x86_64"");
#ifdef ISPC_NVPTX_ENABLED
        else if (m_arch == ""nvptx64"")
            triple = llvm::Triple(""nvptx64"", ""nvidia"", ""cuda"");
#endif /* ISPC_NVPTX_ENABLED */
        else
            triple.setArchName(m_arch);
    }
    return triple.str();
}

// This function returns string representation of ISA for the purpose of
// mangling. And may return any unique string, preferably short, like
// sse4, avx and etc.
const char *Target::ISAToString(ISA isa) {
    switch (isa) {
#ifdef ISPC_ARM_ENABLED
    case Target::NEON8:
        return ""neon-8"";
    case Target::NEON16:
        return ""neon-16"";
    case Target::NEON32:
        return ""neon-32"";
#endif
    case Target::SSE2:
        return ""sse2"";
    case Target::SSE4:
        return ""sse4"";
    case Target::AVX:
        return ""avx"";
    case Target::AVX11:
        return ""avx11"";
    case Target::AVX2:
        return ""avx2"";
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_7 // LLVM 3.7+
    case Target::KNL_AVX512:
        return ""avx512knl"";
#endif
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_8 // LLVM 3.8+
    case Target::SKX_AVX512:
        return ""avx512skx"";
#endif
    case Target::GENERIC:
        return ""generic"";
#ifdef ISPC_NVPTX_ENABLED
    case Target::NVPTX:
        return ""nvptx"";
#endif /* ISPC_NVPTX_ENABLED */
    default:
        FATAL(""Unhandled target in ISAToString()"");
    }
    return """";
}

const char *Target::GetISAString() const { return ISAToString(m_isa); }

// This function returns string representation of default target corresponding
// to ISA. I.e. for SSE4 it's sse4-i32x4, for AVX11 it's avx1.1-i32x8. This
// string may be used to initialize Target.
const char *Target::ISAToTargetString(ISA isa) {
    switch (isa) {
#ifdef ISPC_ARM_ENABLED
    case Target::NEON8:
        return ""neon-8"";
    case Target::NEON16:
        return ""neon-16"";
    case Target::NEON32:
        return ""neon-32"";
#endif
    case Target::SSE2:
        return ""sse2-i32x4"";
    case Target::SSE4:
        return ""sse4-i32x4"";
    case Target::AVX:
        return ""avx1-i32x8"";
    case Target::AVX11:
        return ""avx1.1-i32x8"";
    case Target::AVX2:
        return ""avx2-i32x8"";
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_7 // LLVM 3.7+
    case Target::KNL_AVX512:
        return ""avx512knl-i32x16"";
#endif
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_8 // LLVM 3.8+
    case Target::SKX_AVX512:
        return ""avx512skx-i32x16"";
#endif
    case Target::GENERIC:
        return ""generic-4"";
#ifdef ISPC_NVPTX_ENABLED
    case Target::NVPTX:
        return ""nvptx"";
#endif /* ISPC_NVPTX_ENABLED */
    default:
        FATAL(""Unhandled target in ISAToTargetString()"");
    }
    return """";
}

const char *Target::GetISATargetString() const { return ISAToString(m_isa); }

static bool lGenericTypeLayoutIndeterminate(llvm::Type *type) {
    if (type->isFloatingPointTy() || type->isX86_MMXTy() || type->isVoidTy() || type->isIntegerTy() ||
        type->isLabelTy() || type->isMetadataTy())
        return false;

    if (type == LLVMTypes::BoolVectorType || type == LLVMTypes::MaskType || type == LLVMTypes::Int1VectorType)
        return true;

    llvm::ArrayType *at = llvm::dyn_cast<llvm::ArrayType>(type);
    if (at != NULL)
        return lGenericTypeLayoutIndeterminate(at->getElementType());

    llvm::PointerType *pt = llvm::dyn_cast<llvm::PointerType>(type);
    if (pt != NULL)
        return false;

    llvm::StructType *st = llvm::dyn_cast<llvm::StructType>(type);
    if (st != NULL) {
        for (int i = 0; i < (int)st->getNumElements(); ++i)
            if (lGenericTypeLayoutIndeterminate(st->getElementType(i)))
                return true;
        return false;
    }

    Assert(llvm::isa<llvm::VectorType>(type));
    return true;
}

llvm::Value *Target::SizeOf(llvm::Type *type, llvm::BasicBlock *insertAtEnd) {
    if (m_isa == Target::GENERIC && lGenericTypeLayoutIndeterminate(type)) {
        llvm::Value *index[1] = {LLVMInt32(1)};
        llvm::PointerType *ptrType = llvm::PointerType::get(type, 0);
        llvm::Value *voidPtr = llvm::ConstantPointerNull::get(ptrType);
        llvm::ArrayRef<llvm::Value *> arrayRef(&index[0], &index[1]);
#if ISPC_LLVM_VERSION <= ISPC_LLVM_3_6
        llvm::Instruction *gep = llvm::GetElementPtrInst::Create(voidPtr, arrayRef, ""sizeof_gep"", insertAtEnd);
#else /* LLVM 3.7+ */
        llvm::Instruction *gep =
            llvm::GetElementPtrInst::Create(PTYPE(voidPtr), voidPtr, arrayRef, ""sizeof_gep"", insertAtEnd);
#endif
        if (m_is32Bit || g->opt.force32BitAddressing)
            return new llvm::PtrToIntInst(gep, LLVMTypes::Int32Type, ""sizeof_int"", insertAtEnd);
        else
            return new llvm::PtrToIntInst(gep, LLVMTypes::Int64Type, ""sizeof_int"", insertAtEnd);
    }

    uint64_t byteSize = getDataLayout()->getTypeStoreSize(type);
    if (m_is32Bit || g->opt.force32BitAddressing)
        return LLVMInt32((int32_t)byteSize);
    else
        return LLVMInt64(byteSize);
}

llvm::Value *Target::StructOffset(llvm::Type *type, int element, llvm::BasicBlock *insertAtEnd) {
    if (m_isa == Target::GENERIC && lGenericTypeLayoutIndeterminate(type) == true) {
        llvm::Value *indices[2] = {LLVMInt32(0), LLVMInt32(element)};
        llvm::PointerType *ptrType = llvm::PointerType::get(type, 0);
        llvm::Value *voidPtr = llvm::ConstantPointerNull::get(ptrType);
        llvm::ArrayRef<llvm::Value *> arrayRef(&indices[0], &indices[2]);
#if ISPC_LLVM_VERSION <= ISPC_LLVM_3_6
        llvm::Instruction *gep = llvm::GetElementPtrInst::Create(voidPtr, arrayRef, ""offset_gep"", insertAtEnd);
#else /* LLVM 3.7+ */
        llvm::Instruction *gep =
            llvm::GetElementPtrInst::Create(PTYPE(voidPtr), voidPtr, arrayRef, ""offset_gep"", insertAtEnd);
#endif
        if (m_is32Bit || g->opt.force32BitAddressing)
            return new llvm::PtrToIntInst(gep, LLVMTypes::Int32Type, ""offset_int"", insertAtEnd);
        else
            return new llvm::PtrToIntInst(gep, LLVMTypes::Int64Type, ""offset_int"", insertAtEnd);
    }

    llvm::StructType *structType = llvm::dyn_cast<llvm::StructType>(type);
    if (structType == NULL || structType->isSized() == false) {
        Assert(m->errorCount > 0);
        return NULL;
    }

    const llvm::StructLayout *sl = getDataLayout()->getStructLayout(structType);
    Assert(sl != NULL);

    uint64_t offset = sl->getElementOffset(element);
    if (m_is32Bit || g->opt.force32BitAddressing)
        return LLVMInt32((int32_t)offset);
    else
        return LLVMInt64(offset);
}

void Target::markFuncWithTargetAttr(llvm::Function *func) {
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_3
    if (m_tf_attributes) {
#if ISPC_LLVM_VERSION <= ISPC_LLVM_4_0
        func->addAttributes(llvm::AttributeSet::FunctionIndex, *m_tf_attributes);
#else // LLVM 5.0+
        func->addAttributes(llvm::AttributeList::FunctionIndex, *m_tf_attributes);
#endif
    }
#endif
}

///////////////////////////////////////////////////////////////////////////
// Opt

Opt::Opt() {
    level = 1;
    fastMath = false;
    fastMaskedVload = false;
    force32BitAddressing = true;
    unrollLoops = true;
    disableAsserts = false;
    disableFMA = false;
    forceAlignedMemory = false;
    disableMaskAllOnOptimizations = false;
    disableHandlePseudoMemoryOps = false;
    disableBlendedMaskedStores = false;
    disableCoherentControlFlow = false;
    disableUniformControlFlow = false;
    disableGatherScatterOptimizations = false;
    disableMaskedStoreToStore = false;
    disableGatherScatterFlattening = false;
    disableUniformMemoryOptimizations = false;
    disableCoalescing = false;
}

///////////////////////////////////////////////////////////////////////////
// Globals

Globals::Globals() {
    mathLib = Globals::Math_ISPC;
    codegenOptLevel = Globals::Aggressive;

    includeStdlib = true;
    runCPP = true;
    debugPrint = false;
    printTarget = false;
    NoOmitFramePointer = false;
    debugIR = -1;
    disableWarnings = false;
    warningsAsErrors = false;
    quiet = false;
    forceColoredOutput = false;
    disableLineWrap = false;
    emitPerfWarnings = true;
    emitInstrumentation = false;
    generateDebuggingSymbols = false;
#if ISPC_LLVM_VERSION >= ISPC_LLVM_3_5
    generateDWARFVersion = 3;
#endif
    enableFuzzTest = false;
    fuzzTestSeed = -1;
    mangleFunctionsWithTarget = false;

    ctx = new llvm::LLVMContext;

#ifdef ISPC_IS_WINDOWS
    _getcwd(currentDirectory, sizeof(currentDirectory));
#else
    if (getcwd(currentDirectory, sizeof(currentDirectory)) == NULL)
        FATAL(""Current directory path too long!"");
#endif
    forceAlignment = -1;
    dllExport = false;
}

///////////////////////////////////////////////////////////////////////////
// SourcePos

SourcePos::SourcePos(const char *n, int fl, int fc, int ll, int lc) {
    name = n;
    if (name == NULL) {
        if (m != NULL)
            name = m->module->getModuleIdentifier().c_str();
        else
            name = ""(unknown)"";
    }
    first_line = fl;
    first_column = fc;
    last_line = ll != 0 ? ll : fl;
    last_column = lc != 0 ? lc : fc;
}

#if ISPC_LLVM_VERSION <= ISPC_LLVM_3_6
llvm::DIFile
#else /* LLVM 3.7+ */
llvm::DIFile *
// llvm::MDFile*
#endif
SourcePos::GetDIFile() const {
    std::string directory, filename;
    GetDirectoryAndFileName(g->currentDirectory, name, &directory, &filename);
#if ISPC_LLVM_VERSION <= ISPC_LLVM_3_6
    llvm::DIFile ret = m->diBuilder->createFile(filename, directory);
    Assert(ret.Verify());
#else /* LLVM 3.7+ */
    llvm::DIFile *ret = m->diBuilder->createFile(filename, directory);
#endif
    return ret;
}

void SourcePos::Print() const {
    printf("" @ [%s:%d.%d - %d.%d] "", name, first_line, first_column, last_line, last_column);
}

bool SourcePos::operator==(const SourcePos &p2) const {
    return (!strcmp(name, p2.name) && first_line == p2.first_line && first_column == p2.first_column &&
            last_line == p2.last_line && last_column == p2.last_column);
}

SourcePos Union(const SourcePos &p1, const SourcePos &p2) {
    if (strcmp(p1.name, p2.name) != 0)
        return p1;

    SourcePos ret;
    ret.name = p1.name;
    ret.first_line = std::min(p1.first_line, p2.first_line);
    ret.first_column = std::min(p1.first_column, p2.first_column);
    ret.last_line = std::max(p1.last_line, p2.last_line);
    ret.last_column = std::max(p1.last_column, p2.last_column);
    return ret;
}
",16237,True,2794.603434158063,median
"---
title: 章 7. 多媒體
part: 部 II. 一般作業
prev: books/handbook/desktop
next: books/handbook/kernelconfig
showBookMenu: true
weight: 10
path: ""/books/handbook/""
---

[[multimedia]]
= 多媒體
:doctype: book
:toc: macro
:toclevels: 1
:icons: font
:sectnums:
:sectnumlevels: 6
:sectnumoffset: 7
:partnums:
:source-highlighter: rouge
:experimental:
:images-path: books/handbook/multimedia/

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::[]

[[multimedia-synopsis]]
== 概述

FreeBSD 廣泛地支援各種音效卡， 讓使用者可以享受來自電腦上的高傳真音質(Hi-Fi)， 此外還包括了錄製和播放 MPEG Audio Layer 3 (MP3)、 Waveform Audio File (WAV)、Ogg Vorbis 以及其他許多種格式聲音的能力。同時 FreeBSD Port 套件集也包含了許多可讓您可以錄音、編修音效以及控制 MIDI 配備的應用程式。

FreeBSD 也能播放一般的視訊檔和 DVD。 FreeBSD Port 套件集中含有可編碼、轉換以及播放格種影像媒體的應用程式。

本章會說明如何設定 FreeBSD 上的音效卡、影像播放器、電視卡及掃描器。同時會說明有那些應用程式可以使用這些裝置。

讀完這章，您將了解：

* 設定 FreeBSD 上的音效卡。
* 音效設定疑難排解。
* 播放、錄製 MP3 及其他聲音檔案格式。
* FreeBSD 系統播放影像的準備工具。
* 播放 DVD 的 [.filename]#.mpg# 及 [.filename]#.avi# 檔。
* 擷取(Rip) CD 和 DVD的內容至檔案。
* 設定電視卡。
* 在 FreeBSD 安裝 MythTV
* 設定影像掃描機。
* 設定藍芽耳機。

在開始閱讀這章之前，您需要：

* 知道如何安裝應用程式如 crossref:ports[ports,安裝應用程式：套件與 Port] 所敘述。

[[sound-setup]]
== 設定音效卡

開始設定之前，必須先知道你的音效卡型號、晶片為何。 FreeBSD 支援許多種音效卡，請檢查支援的音效硬體表 https://www.FreeBSD.org/releases/12.0r/hardware/[Hardware Notes]，以確認你的音效卡是否支援以及如何在 FreeBSD 上驅動。

要使用音效裝置，必須要載入正確的驅動程式才行。最簡單方式就是以 man:kldload[8] 來載入核心模組。以下範例示範載入 Intel 規格內建的音效晶片驅動程式：

[source,shell]
....
# kldload snd_hda
....

要開機時自動載入驅動程式，需將驅動程式加到 [.filename]#/boot/loader.conf# 檔，以此驅動程式為例：

[.programlisting]
....
snd_hda_load=""YES""
....

其他可用的音效卡模組清單列於 [.filename]#/boot/defaults/loader.conf#。當不確認要使用何種驅動程式時，可載入 [.filename]#snd_driver# 模組：

[source,shell]
....
# kldload snd_driver
....

它是 metadriver 會載入所有最通用的音效驅動程式並且用來加速尋找正確的驅動程式。也可以把 metadriver 加入 [.filename]#/boot/loader.conf# 檔來載入所有音效驅動程式。

要知道載入 [.filename]#snd_driver# metadriver 後使用了那個音效卡驅動程式，請輸入 `cat /dev/sndstat`。

=== 設定自訂核心支援音效

This section is for users who prefer to statically compile in support for the sound card in a custom kernel. For more information about recompiling a kernel, refer to crossref:kernelconfig[kernelconfig,設定 FreeBSD 核心].

When using a custom kernel to provide sound support, make sure that the audio framework driver exists in the custom kernel configuration file:

[.programlisting]
....
device sound
....

Next, add support for the sound card. To continue the example of the built-in audio chipset based on the Intel specification from the previous section, use the following line in the custom kernel configuration file:

[.programlisting]
....
device snd_hda
....

Be sure to read the manual page of the driver for the device name to use for the driver.

Non-PnP ISA sound cards may require the IRQ and I/O port settings of the card to be added to [.filename]#/boot/device.hints#. During the boot process, man:loader[8] reads this file and passes the settings to the kernel. For example, an old Creative SoundBlaster(TM) 16 ISA non-PnP card will use the man:snd_sbc[4] driver in conjunction with `snd_sb16`. For this card, the following lines must be added to the kernel configuration file:

[.programlisting]
....
device snd_sbc
device snd_sb16
....

If the card uses the `0x220` I/O port and IRQ `5`, these lines must also be added to [.filename]#/boot/device.hints#:

[.programlisting]
....
hint.sbc.0.at=""isa""
hint.sbc.0.port=""0x220""
hint.sbc.0.irq=""5""
hint.sbc.0.drq=""1""
hint.sbc.0.flags=""0x15""
....

The syntax used in [.filename]#/boot/device.hints# is described in man:sound[4] and the manual page for the driver of the sound card.

The settings shown above are the defaults. In some cases, the IRQ or other settings may need to be changed to match the card. Refer to man:snd_sbc[4] for more information about this card.

[[sound-testing]]
=== 測試音效

After loading the required module or rebooting into the custom kernel, the sound card should be detected. To confirm, run `dmesg | grep pcm`. This example is from a system with a built-in Conexant CX20590 chipset:

[source,shell]
....
pcm0: <NVIDIA (0x001c) (HDMI/DP 8ch)> at nid 5 on hdaa0
pcm1: <NVIDIA (0x001c) (HDMI/DP 8ch)> at nid 6 on hdaa0
pcm2: <Conexant CX20590 (Analog 2.0+HP/2.0)> at nid 31,25 and 35,27 on hdaa1
....

The status of the sound card may also be checked using this command:

[source,shell]
....
# cat /dev/sndstat
FreeBSD Audio Driver (newpcm: 64bit 2009061500/amd64)
Installed devices:
pcm0: <NVIDIA (0x001c) (HDMI/DP 8ch)> (play)
pcm1: <NVIDIA (0x001c) (HDMI/DP 8ch)> (play)
pcm2: <Conexant CX20590 (Analog 2.0+HP/2.0)> (play/rec) default
....

The output will vary depending upon the sound card. If no [.filename]#pcm# devices are listed, double-check that the correct device driver was loaded or compiled into the kernel. The next section lists some common problems and their solutions.

If all goes well, the sound card should now work in FreeBSD. If the CD or DVD drive is properly connected to the sound card, one can insert an audio CD in the drive and play it with man:cdcontrol[1]:

[source,shell]
....
% cdcontrol -f /dev/acd0 play 1
....

[WARNING]
====

Audio CDs have specialized encodings which means that they should not be mounted using man:mount[8].
====

Various applications, such as package:audio/workman[], provide a friendlier interface. The package:audio/mpg123[] port can be installed to listen to MP3 audio files.

Another quick way to test the card is to send data to [.filename]#/dev/dsp#:

[source,shell]
....
% cat filename > /dev/dsp
....

where [.filename]#filename# can be any type of file. This command should produce some noise, confirming that the sound card is working.

[NOTE]
====
The [.filename]#/dev/dsp*# device nodes will be created automatically as needed. When not in use, they do not exist and will not appear in the output of man:ls[1].
====

[[bluetooth-headset]]
=== 設定藍芽音效裝置

Connecting to a Bluetooth device is out of scope for this chapter. Refer to crossref:advanced-networking[network-bluetooth,藍牙] for more information.

To get Bluetooth sound sink working with FreeBSD's sound system, users have to install package:audio/virtual_oss[] first:

[source,shell]
....
# pkg install virtual_oss
....

package:audio/virtual_oss[] requires `cuse` to be loaded into the kernel:

[source,shell]
....
# kldload cuse
....

To load `cuse` during system startup, run this command:

[source,shell]
....
# sysrc -f /boot/loader.conf cuse_load=yes
....

To use headphones as a sound sink with package:audio/virtual_oss[], users need to create a virtual device after connecting to a Bluetooth audio device:

[source,shell]
....
# virtual_oss -C 2 -c 2 -r 48000 -b 16 -s 768 -R /dev/null -P /dev/bluetooth/headphones -d dsp
....

[NOTE]
====
_headphones_ in this example is a hostname from [.filename]#/etc/bluetooth/hosts#. `BT_ADDR` could be used instead.
====

請參考 man:virtual_oss[8] 取得更多資訊。

[[troubleshooting]]
=== 疑難排解音效

<<multimedia-sound-common-error-messages>> lists some common error messages and their solutions:

[[multimedia-sound-common-error-messages]]
.常見錯誤訊息
[cols=""1,1"", frame=""none"", options=""header""]
|===
| 錯誤
| 解決方式

|`sb_dspwr(XX) timed out`
|

The I/O port is not set correctly.

|`bad irq XX`
|

The IRQ is set incorrectly. Make sure that the set IRQ and the sound IRQ are the same.

|`xxx: gus pcm not attached, out of memory`
|

There is not enough available memory to use the device.

|`xxx: can't open /dev/dsp!`
|

Type `fstat \\| grep dsp` to check if another application is holding the device open. Noteworthy troublemakers are esound and KDE's sound support.
|===

Modern graphics cards often come with their own sound driver for use with HDMI. This sound device is sometimes enumerated before the sound card meaning that the sound card will not be used as the default playback device. To check if this is the case, run dmesg and look for `pcm`. The output looks something like this:

[.programlisting]
....
...
hdac0: HDA Driver Revision: 20100226_0142
hdac1: HDA Driver Revision: 20100226_0142
hdac0: HDA Codec #0: NVidia (Unknown)
hdac0: HDA Codec #1: NVidia (Unknown)
hdac0: HDA Codec #2: NVidia (Unknown)
hdac0: HDA Codec #3: NVidia (Unknown)
pcm0: <HDA NVidia (Unknown) PCM #0 DisplayPort> at cad 0 nid 1 on hdac0
pcm1: <HDA NVidia (Unknown) PCM #0 DisplayPort> at cad 1 nid 1 on hdac0
pcm2: <HDA NVidia (Unknown) PCM #0 DisplayPort> at cad 2 nid 1 on hdac0
pcm3: <HDA NVidia (Unknown) PCM #0 DisplayPort> at cad 3 nid 1 on hdac0
hdac1: HDA Codec #2: Realtek ALC889
pcm4: <HDA Realtek ALC889 PCM #0 Analog> at cad 2 nid 1 on hdac1
pcm5: <HDA Realtek ALC889 PCM #1 Analog> at cad 2 nid 1 on hdac1
pcm6: <HDA Realtek ALC889 PCM #2 Digital> at cad 2 nid 1 on hdac1
pcm7: <HDA Realtek ALC889 PCM #3 Digital> at cad 2 nid 1 on hdac1
...
....

In this example, the graphics card (`NVidia`) has been enumerated before the sound card (`Realtek ALC889`). To use the sound card as the default playback device, change `hw.snd.default_unit` to the unit that should be used for playback:

[source,shell]
....
# sysctl hw.snd.default_unit=n
....

where `n` is the number of the sound device to use. In this example, it should be `4`. Make this change permanent by adding the following line to [.filename]#/etc/sysctl.conf#:

[.programlisting]
....
hw.snd.default_unit=4
....

[[sound-multiple-sources]]
=== 使用多個音效來源

It is often desirable to have multiple sources of sound that are able to play simultaneously. FreeBSD uses ""Virtual Sound Channels"" to multiplex the sound card's playback by mixing sound in the kernel.

Three man:sysctl[8] knobs are available for configuring virtual channels:

[source,shell]
....
# sysctl dev.pcm.0.play.vchans=4
# sysctl dev.pcm.0.rec.vchans=4
# sysctl hw.snd.maxautovchans=4
....

This example allocates four virtual channels, which is a practical number for everyday use. Both `dev.pcm.0.play.vchans=4` and `dev.pcm.0.rec.vchans=4` are configurable after a device has been attached and represent the number of virtual channels [.filename]#pcm0# has for playback and recording. Since the [.filename]#pcm# module can be loaded independently of the hardware drivers, `hw.snd.maxautovchans` indicates how many virtual channels will be given to an audio device when it is attached. Refer to man:pcm[4] for more information.

[NOTE]
====
The number of virtual channels for a device cannot be changed while it is in use. First, close any programs using the device, such as music players or sound daemons.
====

The correct [.filename]#pcm# device will automatically be allocated transparently to a program that requests [.filename]#/dev/dsp0#.

=== 設定混音器頻道的預設值

The default values for the different mixer channels are hardcoded in the source code of the man:pcm[4] driver. While sound card mixer levels can be changed using man:mixer[8] or third-party applications and daemons, this is not a permanent solution. To instead set default mixer values at the driver level, define the appropriate values in [.filename]#/boot/device.hints#, as seen in this example:

[.programlisting]
....
hint.pcm.0.vol=""50""
....

This will set the volume channel to a default value of `50` when the man:pcm[4] module is loaded.

[[sound-mp3]]
== MP3 音樂

This section describes some MP3 players available for FreeBSD, how to rip audio CD tracks, and how to encode and decode MP3s.

[[mp3-players]]
=== MP3 播放器

A popular graphical MP3 player is Audacious. It supports Winamp skins and additional plugins. The interface is intuitive, with a playlist, graphic equalizer, and more. Those familiar with Winamp will find Audacious simple to use. On FreeBSD, Audacious can be installed from the package:multimedia/audacious[] port or package. Audacious is a descendant of XMMS.

The package:audio/mpg123[] package or port provides an alternative, command-line MP3 player. Once installed, specify the MP3 file to play on the command line. If the system has multiple audio devices, the sound device can also be specified:

[source,shell]
....
# mpg123 -a /dev/dsp1.0 Foobar-GreatestHits.mp3
High Performance MPEG 1.0/2.0/2.5 Audio Player for Layers 1, 2 and 3
        version 1.18.1; written and copyright by Michael Hipp and others
        free software (LGPL) without any warranty but with best wishes

Playing MPEG stream from Foobar-GreatestHits.mp3 ...
MPEG 1.0 layer III, 128 kbit/s, 44100 Hz joint-stereo
....

Additional MP3 players are available in the FreeBSD Ports Collection.

[[rip-cd]]
=== 擷取 CD 音軌

Before encoding a CD or CD track to MP3, the audio data on the CD must be ripped to the hard drive. This is done by copying the raw CD Digital Audio (CDDA) data to WAV files.

The `cdda2wav` tool, which is installed with the package:sysutils/cdrtools[] suite, can be used to rip audio information from CDs.

With the audio CD in the drive, the following command can be issued as `root` to rip an entire CD into individual, per track, WAV files:

[source,shell]
....
# cdda2wav -D 0,1,0 -B
....

In this example, the `-D _0,1,0_` indicates the SCSI device [.filename]#0,1,0# containing the CD to rip. Use `cdrecord -scanbus` to determine the correct device parameters for the system.

To rip individual tracks, use `-t` to specify the track:

[source,shell]
....
# cdda2wav -D 0,1,0 -t 7
....

To rip a range of tracks, such as track one to seven, specify a range:

[source,shell]
....
# cdda2wav -D 0,1,0 -t 1+7
....

To rip from an ATAPI (IDE) CDROM drive, specify the device name in place of the SCSI unit numbers. For example, to rip track 7 from an IDE drive:

[source,shell]
....
# cdda2wav -D /dev/acd0 -t 7
....

Alternately, `dd` can be used to extract audio tracks on ATAPI drives, as described in crossref:disks[duplicating-audiocds,複製音樂 CD].

[[mp3-encoding]]
=== MP3 編碼與解碼

Lame is a popular MP3 encoder which can be installed from the package:audio/lame[] port. Due to patent issues, a package is not available.

The following command will convert the ripped WAV file [.filename]#audio01.wav# to [.filename]#audio01.mp3#:

[source,shell]
....
# lame -h -b 128 --tt ""Foo Song Title"" --ta ""FooBar Artist"" --tl ""FooBar Album"" \\
--ty ""2014"" --tc ""Ripped and encoded by Foo"" --tg ""Genre"" audio01.wav audio01.mp3
....

The specified 128 kbits is a standard MP3 bitrate while the 160 and 192 bitrates provide higher quality. The higher the bitrate, the larger the size of the resulting MP3. The `-h` turns on the ""higher quality but a little slower"" mode. The options beginning with `--t` indicate ID3 tags, which usually contain song information, to be embedded within the MP3 file. Additional encoding options can be found in the lame manual page.

In order to burn an audio CD from MP3s, they must first be converted to a non-compressed file format. XMMS can be used to convert to the WAV format, while mpg123 can be used to convert to the raw Pulse-Code Modulation (PCM) audio data format.

To convert [.filename]#audio01.mp3# using mpg123, specify the name of the PCM file:

[source,shell]
....
# mpg123 -s audio01.mp3 > audio01.pcm
....

To use XMMS to convert a MP3 to WAV format, use these steps:

[.procedure]
====
*Procedure: Converting to WAV Format in XMMS*
. Launch XMMS.
. Right-click the window to bring up the XMMS menu.
. Select `Preferences` under `Options`.
. Change the Output Plugin to ""Disk Writer Plugin"".
. Press `Configure`.
. Enter or browse to a directory to write the uncompressed files to.
. Load the MP3 file into XMMS as usual, with volume at 100% and EQ settings turned off.
. Press `Play`. The XMMS will appear as if it is playing the MP3, but no music will be heard. It is actually playing the MP3 to a file.
. When finished, be sure to set the default Output Plugin back to what it was before in order to listen to MP3s again.
====

Both the WAV and PCM formats can be used with cdrecord. When using WAV files, there will be a small tick sound at the beginning of each track. This sound is the header of the WAV file. The package:audio/sox[] port or package can be used to remove the header:

[source,shell]
....
% sox -t wav -r 44100 -s -w -c 2 track.wav track.raw
....

Refer to crossref:disks[creating-cds,建立與使用 CD 媒體] for more information on using a CD burner in FreeBSD.

[[video-playback]]
== 影片播放

Before configuring video playback, determine the model and chipset of the video card. While Xorg supports a wide variety of video cards, not all provide good playback performance. To obtain a list of extensions supported by the Xorg server using the card, run `xdpyinfo` while Xorg is running.

It is a good idea to have a short MPEG test file for evaluating various players and options. Since some DVD applications look for DVD media in [.filename]#/dev/dvd# by default, or have this device name hardcoded in them, it might be useful to make a symbolic link to the proper device:

[source,shell]
....
# ln -sf /dev/cd0 /dev/dvd
....

Due to the nature of man:devfs[5], manually created links will not persist after a system reboot. In order to recreate the symbolic link automatically when the system boots, add the following line to [.filename]#/etc/devfs.conf#:

[.programlisting]
....
link cd0 dvd
....

DVD decryption invokes certain functions that require write permission to the DVD device.

To enhance the shared memory Xorg interface, it is recommended to increase the values of these man:sysctl[8] variables:

[.programlisting]
....
kern.ipc.shmmax=67108864
kern.ipc.shmall=32768
....

[[video-interface]]
=== 偵測影像處理能力

There are several possible ways to display video under Xorg and what works is largely hardware dependent. Each method described below will have varying quality across different hardware.

Common video interfaces include:

. Xorg: normal output using shared memory.
. XVideo: an extension to the Xorg interface which allows video to be directly displayed in drawable objects through a special acceleration. This extension provides good quality playback even on low-end machines. The next section describes how to determine if this extension is running.
. SDL: the Simple Directmedia Layer is a porting layer for many operating systems, allowing cross-platform applications to be developed which make efficient use of sound and graphics. SDL provides a low-level abstraction to the hardware which can sometimes be more efficient than the Xorg interface. On FreeBSD, SDL can be installed using the package:devel/sdl20[] package or port.
. DGA: the Direct Graphics Access is an Xorg extension which allows a program to bypass the Xorg server and directly alter the framebuffer. Because it relies on a low level memory mapping, programs using it must be run as `root`. The DGA extension can be tested and benchmarked using man:dga[1]. When `dga` is running, it changes the colors of the display whenever a key is pressed. To quit, press kbd:[q].
. SVGAlib: a low level console graphics layer.

[[video-interface-xvideo]]
==== XVideo

To check whether this extension is running, use `xvinfo`:

[source,shell]
....
% xvinfo
....

XVideo is supported for the card if the result is similar to:

[source,shell]
....
X-Video Extension version 2.2
  screen #0
  Adaptor #0: ""Savage Streams Engine""
    number of ports: 1
    port base: 43
    operations supported: PutImage
    supported visuals:
      depth 16, visualID 0x22
      depth 16, visualID 0x23
    number of attributes: 5
      ""XV_COLORKEY"" (range 0 to 16777215)
              client settable attribute
              client gettable attribute (current value is 2110)
      ""XV_BRIGHTNESS"" (range -128 to 127)
              client settable attribute
              client gettable attribute (current value is 0)
      ""XV_CONTRAST"" (range 0 to 255)
              client settable attribute
              client gettable attribute (current value is 128)
      ""XV_SATURATION"" (range 0 to 255)
              client settable attribute
              client gettable attribute (current value is 128)
      ""XV_HUE"" (range -180 to 180)
              client settable attribute
              client gettable attribute (current value is 0)
    maximum XvImage size: 1024 x 1024
    Number of image formats: 7
      id: 0x32595559 (YUY2)
        guid: 59555932-0000-0010-8000-00aa00389b71
        bits per pixel: 16
        number of planes: 1
        type: YUV (packed)
      id: 0x32315659 (YV12)
        guid: 59563132-0000-0010-8000-00aa00389b71
        bits per pixel: 12
        number of planes: 3
        type: YUV (planar)
      id: 0x30323449 (I420)
        guid: 49343230-0000-0010-8000-00aa00389b71
        bits per pixel: 12
        number of planes: 3
        type: YUV (planar)
      id: 0x36315652 (RV16)
        guid: 52563135-0000-0000-0000-000000000000
        bits per pixel: 16
        number of planes: 1
        type: RGB (packed)
        depth: 0
        red, green, blue masks: 0x1f, 0x3e0, 0x7c00
      id: 0x35315652 (RV15)
        guid: 52563136-0000-0000-0000-000000000000
        bits per pixel: 16
        number of planes: 1
        type: RGB (packed)
        depth: 0
        red, green, blue masks: 0x1f, 0x7e0, 0xf800
      id: 0x31313259 (Y211)
        guid: 59323131-0000-0010-8000-00aa00389b71
        bits per pixel: 6
        number of planes: 3
        type: YUV (packed)
      id: 0x0
        guid: 00000000-0000-0000-0000-000000000000
        bits per pixel: 0
        number of planes: 0
        type: RGB (packed)
        depth: 1
        red, green, blue masks: 0x0, 0x0, 0x0
....

The formats listed, such as YUV2 and YUV12, are not present with every implementation of XVideo and their absence may hinder some players.

If the result instead looks like:

[source,shell]
....
X-Video Extension version 2.2
screen #0
no adaptors present
....

XVideo is probably not supported for the card. This means that it will be more difficult for the display to meet the computational demands of rendering video, depending on the video card and processor.

[[video-ports]]
=== 可處理影像的 Port 與套件

This section introduces some of the software available from the FreeBSD Ports Collection which can be used for video playback.

[[video-mplayer]]
==== MPlayer 與 MEncoder

MPlayer is a command-line video player with an optional graphical interface which aims to provide speed and flexibility. Other graphical front-ends to MPlayer are available from the FreeBSD Ports Collection.

MPlayer can be installed using the package:multimedia/mplayer[] package or port. Several compile options are available and a variety of hardware checks occur during the build process. For these reasons, some users prefer to build the port rather than install the package.

When compiling the port, the menu options should be reviewed to determine the type of support to compile into the port. If an option is not selected, MPlayer will not be able to display that type of video format. Use the arrow keys and spacebar to select the required formats. When finished, press kbd:[Enter] to continue the port compile and installation.

By default, the package or port will build the `mplayer` command line utility and the `gmplayer` graphical utility. To encode videos, compile the package:multimedia/mencoder[] port. Due to licensing restrictions, a package is not available for MEncoder.

The first time MPlayer is run, it will create [.filename]#~/.mplayer# in the user's home directory. This subdirectory contains default versions of the user-specific configuration files.

This section describes only a few common uses. Refer to mplayer(1) for a complete description of its numerous options.

To play the file [.filename]#testfile.avi#, specify the video interfaces with `-vo`, as seen in the following examples:

[source,shell]
....
% mplayer -vo xv testfile.avi
....

[source,shell]
....
% mplayer -vo sdl testfile.avi
....

[source,shell]
....
% mplayer -vo x11 testfile.avi
....

[source,shell]
....
# mplayer -vo dga testfile.avi
....

[source,shell]
....
# mplayer -vo 'sdl:dga' testfile.avi
....

It is worth trying all of these options, as their relative performance depends on many factors and will vary significantly with hardware.

To play a DVD, replace [.filename]#testfile.avi# with `dvd://_N_ -dvd-device _DEVICE_`, where _N_ is the title number to play and _DEVICE_ is the device node for the DVD. For example, to play title 3 from [.filename]#/dev/dvd#:

[source,shell]
....
# mplayer -vo xv dvd://3 -dvd-device /dev/dvd
....

[NOTE]
====
The default DVD device can be defined during the build of the MPlayer port by including the `WITH_DVD_DEVICE=/path/to/desired/device` option. By default, the device is [.filename]#/dev/cd0#. More details can be found in the port's [.filename]#Makefile.options#.
====

To stop, pause, advance, and so on, use a keybinding. To see the list of keybindings, run `mplayer -h` or read mplayer(1).

Additional playback options include `-fs -zoom`, which engages fullscreen mode, and `-framedrop`, which helps performance.

Each user can add commonly used options to their [.filename]#~/.mplayer/config# like so:

[.programlisting]
....
vo=xv
fs=yes
zoom=yes
....

`mplayer` can be used to rip a DVD title to a [.filename]#.vob#. To dump the second title from a DVD:

[source,shell]
....
# mplayer -dumpstream -dumpfile out.vob dvd://2 -dvd-device /dev/dvd
....

The output file, [.filename]#out.vob#, will be in MPEG format.

Anyone wishing to obtain a high level of expertise with UNIX(TM) video should consult http://www.mplayerhq.hu/DOCS/[mplayerhq.hu/DOCS] as it is technically informative. This documentation should be considered as required reading before submitting any bug reports.

Before using `mencoder`, it is a good idea to become familiar with the options described at http://www.mplayerhq.hu/DOCS/HTML/en/mencoder.html[mplayerhq.hu/DOCS/HTML/en/mencoder.html]. There are innumerable ways to improve quality, lower bitrate, and change formats, and some of these options may make the difference between good or bad performance. Improper combinations of command line options can yield output files that are unplayable even by `mplayer`.

Here is an example of a simple copy:

[source,shell]
....
% mencoder input.avi -oac copy -ovc copy -o output.avi
....

To rip to a file, use `-dumpfile` with `mplayer`.

To convert [.filename]#input.avi# to the MPEG4 codec with MPEG3 audio encoding, first install the package:audio/lame[] port. Due to licensing restrictions, a package is not available. Once installed, type:

[source,shell]
....
% mencoder input.avi -oac mp3lame -lameopts br=192 \\
	 -ovc lavc -lavcopts vcodec=mpeg4:vhq -o output.avi
....

This will produce output playable by applications such as `mplayer` and `xine`.

[.filename]#input.avi# can be replaced with `dvd://1 -dvd-device /dev/dvd` and run as `root` to re-encode a DVD title directly. Since it may take a few tries to get the desired result, it is recommended to instead dump the title to a file and to work on the file.

[[video-xine]]
==== xine 影像播放器

xine is a video player with a reusable base library and a modular executable which can be extended with plugins. It can be installed using the package:multimedia/xine[] package or port.

In practice, xine requires either a fast CPU with a fast video card, or support for the XVideo extension. The xine video player performs best on XVideo interfaces.

By default, the xine player starts a graphical user interface. The menus can then be used to open a specific file.

Alternatively, xine may be invoked from the command line by specifying the name of the file to play:

[source,shell]
....
% xine -g -p mymovie.avi
....

Refer to http://www.xine-project.org/faq[ xine-project.org/faq] for more information and troubleshooting tips.

[[video-ports-transcode]]
==== Transcode 工具

Transcode provides a suite of tools for re-encoding video and audio files. Transcode can be used to merge video files or repair broken files using command line tools with stdin/stdout stream interfaces.

In FreeBSD, Transcode can be installed using the package:multimedia/transcode[] package or port. Many users prefer to compile the port as it provides a menu of compile options for specifying the support and codecs to compile in. If an option is not selected, Transcode will not be able to encode that format. Use the arrow keys and spacebar to select the required formats. When finished, press kbd:[Enter] to continue the port compile and installation.

This example demonstrates how to convert a DivX file into a PAL MPEG-1 file (PAL VCD):

[source,shell]
....
% transcode -i input.avi -V --export_prof vcd-pal -o output_vcd
% mplex -f 1 -o output_vcd.mpg output_vcd.m1v output_vcd.mpa
....

The resulting MPEG file, [.filename]#output_vcd.mpg#, is ready to be played with MPlayer. The file can be burned on a CD media to create a video CD using a utility such as package:multimedia/vcdimager[] or package:sysutils/cdrdao[].

In addition to the manual page for `transcode`, refer to http://www.transcoding.org/cgi-bin/transcode[transcoding.org/cgi-bin/transcode] for further information and examples.

[[tvcard]]
== 電視卡

電視卡 (TV card) 可以讓您用電腦來看無線、有線電視節目。許多卡都是透過 RCA 或 S-video 輸入端子來接收視訊，而且有些卡還可接收 FM 廣播的功能。

FreeBSD 可透過 man:bktr[4] 驅動程式，來支援 PCI 介面的電視卡，只要這些卡使用的是 Brooktree Bt848/849/878/879 或 Conexant CN-878/Fusion 878a 視訊擷取晶片。此外，要再確認哪些卡上所附的選台功能是否有支援，可以參考 man:bktr[4] 說明，以查看所支援的硬體清單。

=== 載入驅動程式

要用電視卡的話，就要載入 man:bktr[4] 驅動程式，這個可以透過在 [.filename]#/boot/loader.conf# 檔加上下面這一行就可以了：

[.programlisting]
....
bktr_load=""YES""
....

或者可以將電視卡支援靜態編譯到自訂的核心當中，若要這麼做則可在自訂核心設定檔加入以下行：

[.programlisting]
....
device	 bktr
device	iicbus
device	iicbb
device	smbus
....

之所以要加上這些額外的驅動程式，是因為卡的各組成部分都是透過 I2C 匯流排而相互連接的。接下來，請編譯、安裝新的核心 。

要測試調諧器 (Tuner) 是否被正確的偵測，請先重新啟動系統。電視卡應該會出現在開機訊息檔中，如同此範例：

[.programlisting]
....
bktr0: <BrookTree 848A> mem 0xd7000000-0xd7000fff irq 10 at device 10.0 on pci0
iicbb0: <I2C bit-banging driver> on bti2c0
iicbus0: <Philips I2C bus> on iicbb0 master-only
iicbus1: <Philips I2C bus> on iicbb0 master-only
smbus0: <System Management Bus> on bti2c0
bktr0: Pinnacle/Miro TV, Philips SECAM tuner.
....

該訊息會依硬體不同而有所不同。若必要，可以使用 man:sysctl[8] 系統偵測的參數或者自訂核心設定選項。例如要強制使用 Philips SECAM 調諧器則可加入下列行至自訂核心設定檔：

[.programlisting]
....
options OVERRIDE_TUNER=6
....

或使用 man:sysctl[8]：

[source,shell]
....

# sysctl hw.bt848.tuner=6
....

請參考 man:bktr[4] 查看 man:sysctl[8] 可用的參數說明及核心選項。

=== 好用的應用程式

To use the TV card, install one of the following applications:

* package:multimedia/fxtv[] provides TV-in-a-window and image/audio/video capture capabilities.
* package:multimedia/xawtv[] is another TV application with similar features.
* package:audio/xmradio[] provides an application for using the FM radio tuner of a TV card.

More applications are available in the FreeBSD Ports Collection.

=== 疑難排解

If any problems are encountered with the TV card, check that the video capture chip and the tuner are supported by man:bktr[4] and that the right configuration options were used. For more support or to ask questions about supported TV cards, refer to the http://lists.FreeBSD.org/mailman/listinfo/freebsd-multimedia[freebsd-multimedia] mailing list.

[[mythtv]]
== MythTV

MythTV is a popular, open source Personal Video Recorder (PVR) application. This section demonstrates how to install and setup MythTV on FreeBSD. Refer to http://www.mythtv.org/wiki/[mythtv.org/wiki] for more information on how to use MythTV.

MythTV requires a frontend and a backend. These components can either be installed on the same system or on different machines.

The frontend can be installed on FreeBSD using the package:multimedia/mythtv-frontend[] package or port. Xorg must also be installed and configured as described in crossref:x11[x11,X Window 系統]. Ideally, this system has a video card that supports X-Video Motion Compensation (XvMC) and, optionally, a Linux Infrared Remote Control (LIRC)-compatible remote.

To install both the backend and the frontend on FreeBSD, use the package:multimedia/mythtv[] package or port. A MySQL(TM) database server is also required and should automatically be installed as a dependency. Optionally, this system should have a tuner card and sufficient storage to hold recorded data.

=== 硬體

MythTV uses Video for Linux (V4L) to access video input devices such as encoders and tuners. In FreeBSD, MythTV works best with USB DVB-S/C/T cards as they are well supported by the package:multimedia/webcamd[] package or port which provides a V4L userland application. Any Digital Video Broadcasting (DVB) card supported by webcamd should work with MythTV. A list of known working cards can be found at https://wiki.freebsd.org/WebcamCompat[wiki.freebsd.org/WebcamCompat]. Drivers are also available for Hauppauge cards in the package:multimedia/pvr250[] and package:multimedia/pvrxxx[] ports, but they provide a non-standard driver interface that does not work with versions of MythTV greater than 0.23. Due to licensing restrictions, no packages are available and these two ports must be compiled.

The https://wiki.freebsd.org/HTPC[wiki.freebsd.org/HTPC] page contains a list of all available DVB drivers.

=== 設定 MythTV 後端

要使用 Binary 套件安裝 MythTV 可：

[source,shell]
....
# pkg install mythtv
....

或從 Port 套件集安裝：

[source,shell]
....
# cd /usr/ports/multimedia/mythtv
# make install
....

Once installed, set up the MythTV database:

[source,shell]
....
# mysql -uroot -p < /usr/local/shared/mythtv/database/mc.sql
....

Then, configure the backend:

[source,shell]
....
# mythtv-setup
....

Finally, start the backend:

[source,shell]
....
# sysrc mythbackend_enable=yes
# service mythbackend start
....

[[scanners]]
== 影像掃描器

In FreeBSD, access to image scanners is provided by SANE (Scanner Access Now Easy), which is available in the FreeBSD Ports Collection. SANE will also use some FreeBSD device drivers to provide access to the scanner hardware.

FreeBSD supports both SCSI and USB scanners. Depending upon the scanner interface, different device drivers are required. Be sure the scanner is supported by SANE prior to performing any configuration. Refer to http://www.sane-project.org/sane-supported-devices.html[ http://www.sane-project.org/sane-supported-devices.html] for more information about supported scanners.

This chapter describes how to determine if the scanner has been detected by FreeBSD. It then provides an overview of how to configure and use SANE on a FreeBSD system.

[[scanners-kernel-usb]]
=== 檢查掃描器

The [.filename]#GENERIC# kernel includes the device drivers needed to support USB scanners. Users with a custom kernel should ensure that the following lines are present in the custom kernel configuration file:

[.programlisting]
....
device usb
device uhci
device ohci
device ehci
....

To determine if the USB scanner is detected, plug it in and use `dmesg` to determine whether the scanner appears in the system message buffer. If it does, it should display a message similar to this:

[source,shell]
....
ugen0.2: <EPSON> at usbus0
....

In this example, an EPSON Perfection(TM) 1650 USB scanner was detected on [.filename]#/dev/ugen0.2#.

If the scanner uses a SCSI interface, it is important to know which SCSI controller board it will use. Depending upon the SCSI chipset, a custom kernel configuration file may be needed. The [.filename]#GENERIC# kernel supports the most common SCSI controllers. Refer to [.filename]#/usr/src/sys/conf/NOTES# to determine the correct line to add to a custom kernel configuration file. In addition to the SCSI adapter driver, the following lines are needed in a custom kernel configuration file:

[.programlisting]
....
device scbus
device pass
....

Verify that the device is displayed in the system message buffer:

[source,shell]
....
pass2 at aic0 bus 0 target 2 lun 0
pass2: <AGFA SNAPSCAN 600 1.10> Fixed Scanner SCSI-2 device
pass2: 3.300MB/s transfers
....

If the scanner was not powered-on at system boot, it is still possible to manually force detection by performing a SCSI bus scan with `camcontrol`:

[source,shell]
....
# camcontrol rescan all
Re-scan of bus 0 was successful
Re-scan of bus 1 was successful
Re-scan of bus 2 was successful
Re-scan of bus 3 was successful
....

The scanner should now appear in the SCSI devices list:

[source,shell]
....
# camcontrol devlist
<IBM DDRS-34560 S97B>              at scbus0 target 5 lun 0 (pass0,da0)
<IBM DDRS-34560 S97B>              at scbus0 target 6 lun 0 (pass1,da1)
<AGFA SNAPSCAN 600 1.10>           at scbus1 target 2 lun 0 (pass3)
<PHILIPS CDD3610 CD-R/RW 1.00>     at scbus2 target 0 lun 0 (pass2,cd0)
....

Refer to man:scsi[4] and man:camcontrol[8] for more details about SCSI devices on FreeBSD.

=== SANE 設定

The SANE system is split in two parts: the backends (package:graphics/sane-backends[]) and the frontends (package:graphics/sane-frontends[] or package:graphics/xsane[]). The backends provide access to the scanner. Refer to http://www.sane-project.org/sane-supported-devices.html[http://www.sane-project.org/sane-supported-devices.html] to determine which backend supports the scanner. The frontends provide the graphical scanning interface. package:graphics/sane-frontends[] installs xscanimage while package:graphics/xsane[] installs xsane.

要由 Binary 套件安裝這兩個部份可：

[source,shell]
....
# pkg install xsane sane-frontends
....

或由 Port 套件集安裝

[source,shell]
....
# cd /usr/ports/graphics/sane-frontends
# make install clean
# cd /usr/ports/graphics/xsane
# make install clean
....

After installing the package:graphics/sane-backends[] port or package, use `sane-find-scanner` to check the scanner detection by the SANE system:

[source,shell]
....
# sane-find-scanner -q
found SCSI scanner ""AGFA SNAPSCAN 600 1.10"" at /dev/pass3
....

The output should show the interface type of the scanner and the device node used to attach the scanner to the system. The vendor and the product model may or may not appear.

[NOTE]
====
Some USB scanners require firmware to be loaded. Refer to sane-find-scanner(1) and sane(7) for details.
====

Next, check if the scanner will be identified by a scanning frontend. The SANE backends include `scanimage` which can be used to list the devices and perform an image acquisition. Use `-L` to list the scanner devices. The first example is for a SCSI scanner and the second is for a USB scanner:

[source,shell]
....
# scanimage -L
device `snapscan:/dev/pass3' is a AGFA SNAPSCAN 600 flatbed scanner
# scanimage -L
device 'epson2:libusb:/dev/usb:/dev/ugen0.2' is a Epson GT-8200 flatbed scanner
....

In this second example, `'epson2:libusb:/dev/usb:/dev/ugen0.2'` is the backend name (`epson2`) and `/dev/ugen0.2` is the device node used by the scanner.

If `scanimage` is unable to identify the scanner, this message will appear:

[source,shell]
....
# scanimage -L

No scanners were identified. If you were expecting something different,
check that the scanner is plugged in, turned on and detected by the
sane-find-scanner tool (if appropriate). Please read the documentation
which came with this software (README, FAQ, manpages).
....

If this happens, edit the backend configuration file in [.filename]#/usr/local/etc/sane.d/# and define the scanner device used. For example, if the undetected scanner model is an EPSON Perfection(TM) 1650 and it uses the `epson2` backend, edit [.filename]#/usr/local/etc/sane.d/epson2.conf#. When editing, add a line specifying the interface and the device node used. In this case, add the following line:

[.programlisting]
....
usb /dev/ugen0.2
....

Save the edits and verify that the scanner is identified with the right backend name and the device node:

[source,shell]
....
# scanimage -L
device 'epson2:libusb:/dev/usb:/dev/ugen0.2' is a Epson GT-8200 flatbed scanner
....

Once `scanimage -L` sees the scanner, the configuration is complete and the scanner is now ready to use.

While `scanimage` can be used to perform an image acquisition from the command line, it is often preferable to use a graphical interface to perform image scanning. The package:graphics/sane-frontends[] package or port installs a simple but efficient graphical interface, xscanimage.

Alternately, xsane, which is installed with the package:graphics/xsane[] package or port, is another popular graphical scanning frontend. It offers advanced features such as various scanning modes, color correction, and batch scans. Both of these applications are usable as a GIMP plugin.

=== 掃描器權限

In order to have access to the scanner, a user needs read and write permissions to the device node used by the scanner. In the previous example, the USB scanner uses the device node [.filename]#/dev/ugen0.2# which is really a symlink to the real device node [.filename]#/dev/usb/0.2.0#. The symlink and the device node are owned, respectively, by the `wheel` and `operator` groups. While adding the user to these groups will allow access to the scanner, it is considered insecure to add a user to `wheel`. A better solution is to create a group and make the scanner device accessible to members of this group.

This example creates a group called `_usb_`:

[source,shell]
....
# pw groupadd usb
....

Then, make the [.filename]#/dev/ugen0.2# symlink and the [.filename]#/dev/usb/0.2.0# device node accessible to the `usb` group with write permissions of `0660` or `0664` by adding the following lines to [.filename]#/etc/devfs.rules#:

[.programlisting]
....
[system=5]
add path ugen0.2 mode 0660 group usb
add path usb/0.2.0 mode 0666 group usb
....

Finally, add the users to `_usb_` in order to allow access to the scanner:

[source,shell]
....
# pw groupmod usb -m joe
....

For more details refer to man:pw[8].
",12088,False,2098.3396639519265,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.
//

= Profiling an Enterprise Application in IDE NetBeans
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Profiling an Enterprise Application in IDE NetBeans - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Profiling an Enterprise Application in IDE NetBeans

IDE NetBeans includes a powerful profiling tool that can provide important information about the runtime behavior of enterprise applications. С помощью средства профилирования можно легко следить за состояниями потоков и получать данные о производительности ЦП и использовании приложением памяти.

В этом документе говорится об использовании средства профилирования для получения данных о простых приложениях, которые развернуты на сервере приложений как файлы WAR. В документе показано, как использовать среду IDE, чтобы получить результаты профилирования следующих показателей.

* Поведение приложения при выполнении
* Время ЦП, используемое методами приложения
* Создание объекта

При развертывании приложения на локальном зарегистрированном сервере Tomcat, сервере GlassFish или установке JBoss приложение можно профилировать всего лишь несколькими нажатиями кнопок мыши и почти не настраивая. Процесс профилирования проекта очень похож на использование команды ""Выполнить"" в среде IDE. Можно с легкостью начать профилирование проектов приложений или отдельных веб-модулей и модулей EJB, выбрав пункт ""Профиль"" > ""Профилировать главный проект"" главного меню.


* Создание примера проекта

*Для работы с этим учебным курсом требуется следующее программное обеспечение и ресурсы.*

|===
|Программное обеспечение или материал |Требуемая версия 

|link:https://netbeans.org/downloads/index.html[+IDE NetBeans+] |7.3, 7.4, 8.0, пакет Java EE 

|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+Комплект для разработчика на языке Java (JDK)+] |JDK 7 или 8 

|Сервер GlassFish |3.1, 4.0 
|===

[NOTE]
====
* При первом использовании профилировщика рекомендуется ознакомиться с разделом link:../java/profiler-intro.html[+Введение в профилирование приложений Java в IDE NetBeans+], который содержит обзор задач отслеживания и профилирования.
* Если используется IDE NetBeans 7.2 или более ранняя версия, см. раздел link:../../72/javaee/profiler-javaee.html[+Профилирование корпоративных приложений в IDE NetBeans 7.2+]
* В этом документе говорится о профилировании корпоративного приложения, развернутого на сервере GlassFish. Предпочтительная и самая простая настройка профилирования во время разработки корпоративных или веб-приложений — запуск приложения на локальных серверах Tomcat, GlassFish или JBoss.
====


== О профилировании приложений в среде IDE

При профилировании корпоративных приложений в большинстве случаев требуется анализировать производительность приложения для получения времени выполнения методов проекта. Это позволяет исправить ошибки приложения и улучшить его производительность. В некоторых случаях требуется также получить данные по использованию памяти для оптимизации сбора мусора.

Процесс профилирования корпоративных приложений, модулей EJB и веб-приложений по сути такой же, как выполнение проекта с помощью команды ""Выполнить"". После выбора задачи профилирования и настройки параметров нажмите ""Выполнить"" в диалоговом окне ""Выбрать задачу профилирования"" для запуска сессии профилирования. При запуске сеанса профилирования среда IDE выполняет следующие действия:

* компилирует приложение;
* запускает целевой сервер в режиме профилирования;
* развертывает приложение;
* прикрепляется к приложению;
* открывает веб-страницу веб-браузера (если это указано в свойствах проекта);
* открывает вкладку ""Текущие результаты профилирования"".

В зависимости от параметров профилирования среда IDE может немедленно вывести результаты профилирования во вкладке ""Текущие результаты профилирования"". В некоторых случаях, например, при указании профилирования корневых методов, может оказаться необходимым произвести некоторые действия в веб-браузере, прежде чем будут показаны результаты.


=== Профилирование проектов корпоративных приложений

Корпоративное приложение, которое создается в среде IDE, может быть и веб-приложением, которое развертывается на сервере приложений как архивный веб-файл (WAR), и проектом корпоративного приложения, содержащим веб-приложение и дополнительные библиотеки, развернутым на сервере как архивный файл корпоративного приложения (EAR).

Если необходимо развернуть приложение как архивный файл EAR, создайте проект корпоративного приложения NetBeans, который содержит подпроекты и библиотеки. Проект корпоративного приложения не содержит ни одного исходного файла, только информацию о сборке и развертывании приложения и о метаданных настроек сервера. Бизнес-логика приложения проекта обычно содержится в модуле EJB, а исходный код уровня представления — в веб-модуле.

При наличии всех исходных файлов проекта корпоративного приложения самым лучшим и простым методом профилирования является профилирование всего проекта корпоративного приложения целиком, а не его подпроектов. Это позволяет удостовериться, что весь необходимый код был скомпилирован и развернут, а приложение работает корректно. Чтобы профилировать проект корпоративного приложение, выполните следующие действия:

* Если проект является главным проектом, нажмите кнопку ""Профилировать главный проект"" на панели инструментов или выберите ""Профилирование"" > ""Профилировать главный проект"" в главном меню.
* Щелкните правой кнопкой мыши проект приложения в окне проектов и выберите ""Профилировать"" из всплывающего меню.

При профилировании корпоративного приложения можно увеличить корректность результатов профилирования, указав профилирование корневых методов и используя фильтры инструментирования для ограничения количества классов, которые будут профилированы. Это поможет сократить влияние дополнительного расхода ресурсов процессом профилирования на производительность приложения и увеличит корректность результатов профилирования.

При запуске корпоративных приложений, в отличие от веб-приложений, браузер не всегда открывается автоматически. (Это зависит от настройки проекта.) Это означает, что в некоторых случаях понадобится вручную запустить внешний интерфейс веб-приложения и затем вызвать код, такой как бизнес-логика в модуле EJB, из веб-браузера.


=== Профилирование модуля EJB и подпроектов веб-модулей

Сеанс профилирования можно запустить из любого модуля EJB или веб-модуля проекта. В этом случае можно выбрать один из подходов:

* *Профилирование модуля EJB.* Если использовать этот подход, возможно, придется вызывать код приложения вручную с веб-браузера или другого клиента, поскольку проекты модулей EJB, как правило, не настроены для открытия веб-браузера. После того, как модуль EJB развернут на сервере, необходимо вызвать его код точно так же, как при отладке или оценке функциональности приложения. Обычно это делается запуском внешнего интерфейса веб-приложения и выполнения действий в веб-браузере.
* *Профилирования веб-модуля.* Если использовать этот подход, необходимо скомпилировать и развернуть модуль EJB на сервер до профилирования проекта веб-модуля. Обычно код EJB выполняется в результате некоторых действий пользователя в браузере. Если эти действия выполнены/обработаны кодом веб-приложения, код EJB будет виден в дереве вызовов.


== Создание примера проекта

В этом документе говорится о профилировании демонстрационного приложения ServletStateless. Приложение ServletStateless — это простое корпоративное веб-приложение, которое включено в среду IDE как демонстрационный проект.

Для создания приложения ServletStateless выполните следующие действия:

1. Выберите 'Файл' > 'Создать проект' (Ctrl-Shift-N; ⌘-Shift-N в Mac) в главном меню.
2. В мастере создания проекта выберите категорию ""Примеры > Java EE"".
3. Выберите проект ""Servlet Stateless"". Нажмите кнопку ""Далее"".
4. Укажите местоположение проекта. Нажмите кнопку ""Завершить"".

После нажатия кнопки ""Готово"" среда IDE создает демонстрационный проект ServletStateless. Проект ServletStateless отображается в окне 'Проекты'.

[NOTE]
====
* По умолчанию, при использовании среды IDE для профилирования проекта, IDE выполнит профилирование проекта, выбранного в окне 'Проекты', если открыто более одного проекта. Если выбрать 'Выполнить' > 'Задать главный проект' в главном меню и задать проект как главный, то профилирование главного проекта выполняется по умолчанию. Можно щелкнуть правой кнопкой мыши узео проекта в окне 'Проекты' и выбрать 'Профиль' во всплывающем меню.
* Если необходимо выполнить профилирование такого файла, как страница  ``.jsp``  или сервлет, щелкните правой кнопкой мыши файл и выберите 'Профилировать файл' во всплывающем меню. Процесс профилирования такой же, как при выборе ""Профилирование главного проекта"", но при запуске сессии профилирования в браузере откроется выбранная страница вместо страницы проекта по умолчанию.
====


== Наблюдение за приложением

Наблюдение за приложением позволяет получать информацию о свойствах целевой виртуальной машины Java, включая активность потоков и распределение памяти. Поскольку наблюдение за приложением не требует большого дополнительного расхода ресурсов, можно запускать приложение в этом режиме в течение длительного времени. При выборе задачи наблюдения целевое приложение запускается без каких-либо инструментов.

Для отслеживания приложения ServletStateless выполните следующие действия:

1. Выберите 'Выполнить' > 'Задать главный проект' > ServletStateless для задания проекта как главного.

При настройке проекта как главного, имя проекта будет выделено полужирным в окне 'Проекты'.



. Выберите ""Профиль > Профилировать главный проект"" в главном меню.

NOTE:  Выберите JDK 1.7 или JDK 1.8 при отображении запроса на выбор платформы Java для профилирования.



. Выберите ""Наблюдение"" в диалоговом окне ""Выбор задачи профилирования"".


. Нажмите кнопку ""Выполнить"".

NOTE:  Если средство профилирования не использовалось ранее, может быть отображен запрос на калибровку средства профилирования до выбора 'Выполнить'. Дополнительные сведения о калибровке профилировщика см. раздел link:../java/profiler-intro.html#calibrate[+Первое использование профилировщика+] в link:../java/profiler-intro.html[+Введение в профилирование приложений Java в IDE NetBeans+].

По кнопке ""Выполнить"" среда IDE собирает приложение, запускает сервер в режиме профилирования, а затем разворачивает приложение на сервере. Затем среда IDE прикрепляется к приложению и запускает извлечение данных.

Данные о потоках целевой виртуальной машины Java отображаются на вкладке ""Потоки"". Вкладка ""Потоки"" отображает данные по всем потокам, как серверным, так и потокам приложения.

Дополнительную информацию о наблюдении можно получить, нажав кнопку ""Обзор телеметрии"" в окне ""Профилировщик"", чтобы открылось окно ""Обзор телеметрии виртуальной машины"". Окно ""Обзор телеметрии виртуальной машины"" позволяет быстро просмотреть данные наблюдения в реальном времени. Щелкнув два раза график в окне ""Обзор телеметрии виртуальной машины"", можно открыть более крупную версию изображения графика.

При наблюдении за корпоративным приложением графики Memory (Heap) и Memory (GC) (график ""кучи"" памяти и график использования памяти при сборке мусора) помогают быстро проследить использование памяти приложением. Наведя указатель мыши на график, можно получить подсказку с более подробной информацией. Равномерное увеличение размера ""кучи"" или числа сохранившихся поколений указывает на утечку памяти. При подозрении на утечку памяти следует профилировать использование памяти приложением.

image::images/monitor-memory-telemetry.png[title=""График памяти (GC), на котором отображаются данные GC""] 


== Анализ производительности приложения

Задача анализа производительности ЦП позволяет увидеть данные производительности ЦП на уровне методов (время запуска) и количество вызовов методов из приложения. Можно предпочесть анализ производительности всего приложения или выбрать корень профилирования, чтобы применить профилирование только для части кода приложения.

image::images/sample-task.png[title=""Режим образца приложения выбран на панели ЦП диалогового окна 'Выбор задачи профилирования'""]

При запуске задачи анализа производительности ЦП в окне ""Задачи профилирования"" можно выбрать, какую часть приложения профилировать, отметив один из перечисленных параметров:

* *Быстрый (образец).* В этом режиме IDE создает образец приложения и периодически создает трассировку стека. Этот вариант менее точен, чем методы инструментирования, но вызывает меньший дополнительный расход ресурсов. Этот вариант может помочь выбрать методы для инструментирования.
* *Расширенный (инструментация).* В этом режиме методы профилируемого приложения инструментируются. Среда IDE регистрирует вход и выход потоков в методы проекта, позволяя отслеживать время, затрачиваемое на каждый метод. При входе в метод потоки создают событие ""вход в метод"". При выходе из метода потоки создают соответствующее событие ""выход из метода"". Записываются метки времени обоих событий. Эти данные обрабатываются в реальном времени.

Можно выбрать инструментирование всех методов приложения или ограничить инструментирование поднабором кода приложения, указав один или несколько *корневых методов*. Определение корневых методов может сильно уменьшить дополнительный расход ресурсов на профилирование. Корневой метод — это метод, класс или пакет в исходном коде, который можно указать как корень обработки. Данные профилирования собираются при входе и выходе одного из потоков приложения из корня обработки. До входа одного из потоков приложения в корневой метод данные профилирования не собираются. Корневой метод можно указать, используя всплывающее меню в исходном коде, или щелкнув *настроить*, чтобы открыть диалоговое окно ""Изменить корневые методы профилирования"".

*Советы про профилированию веб-приложений*

* В дополнение к основным классам Java, корпоративные приложения обычно вызывают ряд методов в классах на целевом сервере. По этой причине важно настроить фильтр для ограничения количества исходного кода, которое необходимо инструментировать. Рекомендуется использовать фильтр *Профилировать только классы проекта* при профилировании корпоративных приложений.
* Результаты профилирования собираются сразу при запуске сеанса профилирования. Если при использовании метода 'Расширенный' не указано профилирования ни одного корневого метода, некоторые интересные данные можно получить сразу же после запуска сервера, а именно прослушивателей веб-приложений и инициализации фильтров. Если указано профилирование неких корневых методов, эти данные, скорее всего, получены не будут. Их получение зависит от выбранных корневых методов.
* Обычно данные прослушивателей и фильтров не бывают интересными, поэтому для их удаления можно нажать кнопку ""Сбросить собранные результаты"". Первые полезные данные собираются после того, как в результате некоторого действия в веб-браузере вызывается некоторый код, обычно это отображение страницы JSP, которая использует JavaBeans и/или избранные теги, или обработка методов  ``doGet`` / ``doPost``  сервлета. Следует отметить, что данные, которые собираются при первом запуске приложения, обычно отражают только поведение веб-приложения при запуске.
* Если страница JSP отображается впервые, она сервером внутренне компилируется в сервлет, что влияет на дерево вызовов и подсчет времени обработки метода. К тому же поведение кода сервлетов и других приложений при первом запуске может слегка отличаться от их поведения при производственной эксплуатации, когда они запущены постоянно. Для получения данных измерений, которые бы лучше характеризовали производительность приложения, перед измерением любых временных показателей следует увеличить рабочую нагрузку на профилируемый код (не должно повлиять на деревья вызовов). Для увеличения рабочей нагрузки можно использовать генераторы нагрузки. (Дополниетльные сведения см. в разделе link:../java/profile-loadgenerator.html[+Использование генератора нагрузки в IDE NetBeans+]). Средства кэширования у различных браузеров также могут повлиять на производительность.

NOTE:  При профилировании веб-приложений на сервере приложений GlassFish на компьютере под управлением Windows при запуске сервера для профилирования может произойти ошибка, если путь установки IDE NetBeans содержит пробелы (как например при установке в каталог по умолчанию  ``C:\\Program Files\\netbeans-7.4`` ). В качестве временного решения можно установить или скопировать каталог установки IDE NetBeans в местоположение, путь к которому не содержит пробелов (например,  ``C:\\netbeans-7.4`` ).


=== Опрос приложения

Вариант ""Быстрый"" используется для обзора режима работы всего приложения в целом, когда нет необходимости в инструментировании методов. В режиме опроса приложения профиль Quick периодически снимает данные трассировки. Расход системных ресурсов в режиме профилирования 'Быстрый' меньше, чем в режиме профилирования 'Расширенный'.

В следующем упражнении будет проанализирована производительность приложения в режиме профилирования 'Быстрый'.

1. Остановите сеанс наблюдения, нажав кнопку ""Стоп"" в меню ""Профилирование"".
2. Выберите ""Профиль > Профилировать главный проект"" в главном меню.
3. Выберите ""ЦП"" в диалоговом окне ""Выбор задачи профилирования"".
4. Выберите режим *Быстрый (образец)*.
5. Выберите *Профилировать только классы проекта* из раскрывающегося списка фильтров. Нажмите кнопку ""Выполнить"".

NOTE:  Этот фильтр ограничит классы, инструментированные для классов, найденных в проекте корпоративного приложения. Нажмите кнопку *Показать значение фильтра*, чтобы увидеть список отфильтрованных классов.

image::images/sample-task.png[title=""Режим образца приложения выбран на панели ЦП диалогового окна 'Выбор задачи профилирования'""]

По шкале в диалоговом окне можно заметить, что трата системных ресурсов относительно невысока.



. Нажмите кнопку ""Текущие результаты профилирования"" в окне ""Профилирование"", чтобы открыть вкладку текущих результатов профилирования.

image::images/sample-task-results.png[title=""Результаты режима 'Образцы приложений'""]

На вкладке ""Текущие результаты профилирования"" показано время выполнения метода  ``service``  для сервлета из класса  ``Servlet2Stateless``  и то, что метод был вызван один раз.


=== Инструментирование всех методов

В режиме ""Профилирование приложения"" все методы приложения инструментируются. Хотя это более точный метод изменения производительности приложения, трата системных ресурсов при профилировании выше, чем в режиме опроса. Можно настроить профилирование корневых методов так, чтобы ограничить количество инструментируемых методов и уменьшить загрузку при профилировании. Для некоторых приложений указание корневого метода может быть единственным способом получения подробных и/или реалистичных данных производительности, поскольку профилирование всего приложения может создать так много данных профилирования, что приложение станет непригодным к использованию, или даже произойдет отказ приложения.

В следующем упражнении будет проанализирована производительность приложения с помощью инструментирования всех его методов.

1. Остановите сеанс наблюдения, нажав кнопку ""Стоп"" в меню ""Профилирование"".
2. Выберите ""Профиль > Профилировать главный проект"" в главном меню.
3. Выберите ""ЦП"" в диалоговом окне ""Выбор задачи профилирования"".
4. Выберите режим *Расширенный (инструментарий)*.
5. Выберите *Профилировать только классы проекта* из раскрывающегося списка фильтров. Нажмите кнопку ""Выполнить"".

image::images/advanced-cpu-task.png[title=""Режим профилирования приложения выбран на панели ЦП диалогового окна 'Выбор задачи профилирования'""]

По шкале в диалоговом окне можно заметить, что трата системных ресурсов выше, чем в режиме быстрого профилирования.



. Нажмите кнопку ""Текущие результаты профилирования"" в окне ""Профилирование"", чтобы открыть вкладку текущих результатов профилирования.

На вкладке ""Текущие результаты профилирования"" показано время выполнения методов  ``init``  и  ``service``  для сервлета из класса  ``Servlet2Stateless`` , и то, что каждый из методов был вызван один раз. Метод  ``init``  в классе  ``StatelessSessionBean`` также был вызван.

image::images/cpu-pane1-results.png[title=""Результаты режима 'Профилирование приложений'""]

NOTE:  По умолчанию режим автоматического обновления активен, что обеспечивает обновление отображаемых данных каждые несколько секунд. Можно включать или отключать режим автоматического обновления, нажав кнопку ""Автообновление"" на панели инструментов.

Для повышения удобочитаемости собранные данные можно фильтровать, используя фильтр ""Результаты"" в списке ""Просмотр горячих точек"" окна ""Текущие результаты профилирования"". Фильтр ""Результаты"" формирует выборку только по результатам и не затрагивает обрабатываемые классы. Используя фильтр ""Результаты"", можно отбирать результаты, которые соответствуют определенному шаблону. Для фильтрации можно использовать также более сложные регулярные выражения. Данные фильтруются по именам пакетов/классов/методов, в точности, как они появляются в первой колонке таблицы результатов. Можно определить более, чем один шаблон фильтрации, разделяя их пробелом или точкой с пробелом.



. Введите свое имя в поле в веб-браузере и нажмите ""Отправить запрос"".

image::images/cpu-pane1-results1.png[title=""Результаты режима 'Профилирование приложений'""]

По нажатию кнопки ""Отправить запрос""данные на вкладке ""Текущие результаты профилирования"" обновляются для отражения действий в веб-браузере. Нажатие кнопки запускает метод  ``sayHello``  в классе  ``StatelessSessionBean``  и вновь вызывает метод  ``init`` .  ``Служебный``  метод для сервлета из  ``Servlet2Stateless``  также был вызван вновь. Вкладка ""Текущие результаты профилирования"" также показывает, сколько времени было затрачено в каждом из методов.

Чтобы увидеть графическое представление относительного времени, затраченного в различных областях приложения (сервлетах, прослушивателях и т.д.), нажмите кнопку ""Развернуть"". Можно нажать на сам график, чтобы развернуть результаты профилирования на экран.

image::images/drill-down.png[title=""График перехода по иерархии относительного времени, потраченного в сервлетах в приложении""]

Инструментирование приложения всегда затрачивает некоторое количество системных ресурсов на профилирование. В таком простом приложении затрата системных ресурсов незаметна, но в сложных приложениях она может быть весьма значительной. Можно уменьшить затраты системных ресурсов ограничением количества профилируемых классов, выбрав профилирование корневого метода.


=== Использование профилирования корневых методов

В следующем упражнении будет профилирована только часть приложения. Этот метод профилирования используется, если известны потенциальные ""узкие места"" приложения, касающиеся производительности, или если необходимо профилировать определенную часть кода, например, один из нескольких сервлетов. При этом методе на профилирование обычно затрачивается гораздо меньше системных ресурсов, чем при методе инструментирования всего приложения. При инструментировании только с части приложения собираются и отображаются только интересующие данные.

Чтобы профилировать часть приложения, необходимо назначить один или более корневых методов профилирования. Среда IDE инструментирует только те методы, которые вызываются потоком, входящим в корневой метод профилирования. Например, если назначить метод  ``sayHello``  в классе  ``StatelessSessionBean``  корневым методом и использовать фильтр ""Профилировать только классы проекта"", среда IDE запустит методы инструментирования при вызове метода, когда в него войдет поток приложения. В этом приложении конструктор  ``init``  не будет инструментирован, поскольку он вызывается перед  ``sayHello`` .

image::images/profileroot-sayhello-project.png[title=""График перехода по иерархии относительного времени, потраченного в сервлетах в приложении""]

Если выбрать фильтр ""Профилировать все классы"", среда IDE инструментирует все методы, вызванные  ``sayHello`` , включая базовые классы языка Java.

image::images/profileroot-sayhello-all.png[title=""График перехода по иерархии относительного времени, потраченного в сервлетах в приложении""]

NOTE:  В более комплексных приложениях может потребоваться указание нескольких корневых методов. В качестве корней профилирования можно выбрать отдельные методы, целые классы и пакеты.

Чтобы указать корень профилирования и проанализировать производительность приложения, выполните следующие действия.

1. Остановите предыдущие сессии профилирования (если они все еще запущены), нажав кнопку ""Завершить"" в окне ""Профилирование"".
2. Выберите ""Профиль > Профилировать главный проект"" в главном меню.
3. Выберите ""ЦП"" в диалоговом окне ""Выбор задачи профилирования"".
4. Выберите режим *Расширенный (инструментарий)*.
5. Нажмите кнопку *настроить*, чтобы открыть диалоговое окно ""Изменение корневых методов профилирования"".

Чтобы профилировать часть приложения необходимо сначала определить корневые методы. После выбора корневого метода профилирование будет применяться только к тем методам, которые вызываются потоком, входящим в корень профилирования.



. В диалоговом окне ""Изменить корневые методы профилирования"" выберите ""Вид веб-приложения"" в раскрывающемся списке ""Выбрать вид"".


. Разверните узел ServletStateless и выберите метод  ``service``  в пакете сервлетов. Нажмите кнопку ""ОК"".

image::images/edit-profiling-roots.png[title=""Представление веб-приложения в диалоговом окне 'Изменение корневых методов профилирования'""]

В противном случае можно выбрать ""Просмотр пакета"", чтобы увидеть все исходные пакеты приложения и выбрать метод  ``service``  из класса  ``Servlet2Stateless``  пакета  ``servlet.stateless`` .

image::images/edit-profiling-roots-pkg.png[title=""Представление пакета в диалоговом окне 'Изменение корневых методов профилирования'""]

NOTE:  Обратите внимание, что конструктор  ``Servlet2Stateless``  не выбран. Диалог ""Изменить корневые методы профилирования"" используется, чтобы применять инструментирование только к определенным методам класса. Если нет необходимости применять инструментирование только к определенным методам, можно использовать представление пакетов, чтобы выбрать весь класс или пакет. Например, если выбрать класс  ``Servlet2Stateless``  в представлении пактов диалога ""Изменить корневые методы профилирования"", среда IDE инструментирует конструктор  ``init``  и метод  ``service`` .

Если нажать кнопку ""Дополнительно"", можно увидеть, что метод  ``service``  представлен в диалоговом окне ""Изменить корневые методы профилирования (Дополнительно)"", как единственный корневой метод. Чтобы явно определить метод, добавив ему подпись и класс, нажмите кнопку ""Добавить"".

image::images/edit-profilingroots-pkg-adv.png[title=""Диалоговое окно 'Изменение корневых методов профилирования' (Расширенное)""]



. Нажмите кнопку ""ОК"" в диалоговом окне ""Изменить корневые методы профилирования"".

В диалоговом окне ""Выбрать задачу профилирования"" видно, что режим расширенного профилирования будет запущен с помощью специальных корневых методов профилирования. Чтобы просмотреть и изменить выбранный корневой метод нажмите *Изменить*. Заметим, что затраты системных ресурсов после этих действий ниже, чем была до настройки корневых методов.



. Выберите *Профилировать только классы проекта* из раскрывающегося списка фильтров. Нажмите кнопку ""Выполнить"".

image::images/advanced-cpu-task-custom.png[title=""Режим профилирования приложения выбран с нестандартным корнем профилирования""]

При нажатии кнопки ""Запустить"" среда IDE собирает и разворачивает приложение и открывает в веб-браузере страницу сервлета.

В среде IDE результаты профилирования показываются на вкладке ""Текущие результаты профилирования"".

image::images/cpu-pane2-results.png[title=""Результаты методов инструментирования с использованием корня профилирования""]

Можно увидеть, что в среде IDE показываются результаты только для метода, определенного как корень профилирования. Поток приложения не вошел больше ни в один из методов приложения после входа в корень профилирования.

Хотя поток приложения выполнил вход в другие методы после входа в корень профилирования, эти методы не отображаются, поскольку фильтр инструментирования отбирает для инструментирования только те классы, которые являются частью проекта.



. Введите свое имя в поле в веб-браузере и нажмите ""Отправить запрос"".

image::images/cpu-pane2-results1.png[title=""Результаты методов инструментирования с использованием корня профилирования после вызова метода sayHello""]

По нажатию кнопки ""Отправить запрос""данные на вкладке ""Текущие результаты профилирования"" обновляются для отражения действий в веб-браузере. Нажатие кнопки вызывает метод  ``sayHello``  класса  ``StatelessSessionBean``  один раз. Метод  ``service``  также заново вызывается.

Результирующие данные, которые отражают производительность приложения, могут не совсем точно описывать производительность приложения, работающего уже некоторое время. Один из способов сымитировать поведение веб-приложения в более реальных условиях — запустить сценарий генератора загрузки.



. Повторите в браузере предыдущее действие несколько раз, затем нажмите ""Сбросить результаты"" на вкладке ""Текущие результаты профилирования"" для удаления результатов.


. После сброса результатов профилирования введите свое имя и нажмите ""Отправить запрос"" еще раз.

image::images/cpu-pane2-results2.png[title=""Результаты методов инструментирования с использованием корня профилирования после вызова метода sayHello""]

При взгляде на результаты профилирования в большинстве случаев заметно, что производительность приложения улучшилась.


=== Использование инструментальных фильтров

При анализе производительность ЦП можно уменьшить затраты системных ресурсов с помощью инструментального фильтра, который отберет для профилирования интересующую части кода приложения. Фильтр отбирает пакеты/классы для инструментирования. Можно выбрать фильтр из следующего списка фильтров по умолчанию или создать индивидуальный.

* *Профилирование всех классов.* Если выбрать этот фильтр при профилировании веб-приложений или корпоративных приложений, инструментируются все классы, включая основные классы Java и классов серверов. Этот фильтр необходимо использовать с осторожностью, поскольку инструментирование такого большого количества классов может повлечь *очень* значительные затраты системных ресурсов.
* *Профилирование только классов проекта.* При профилировании корпоративного приложения рекомендуется использовать именно этот фильтр, чтобы инструментировать только классы проекта. Серверные классы не будут инструментированы.
* *Профилирование классов проектов и подпроектов.* При профилировании проекта корпоративного приложения, которое содержит подпроекты, такие как веб-приложения, модули EJB или библиотеки классов, можно выбрать этот фильтр, чтобы ограничить инструментированного кода для классов в подпроектах.

Можно создать индивидуальный фильтр, который будет использоваться в определенном проекте или для определенных типов профилирования. Например, если требуется использовать инструментальный фильтр для профилирования веб-приложений на сервере Oracle WebLogic, можно нажать кнопку ""Изменить набор фильтров"" и создать набор фильтров, которые будут исключать из процесса инструментирования базовые классы языка Java, классы Oracle WebLogic и классы NetBeans (удобно при отключенном мониторинге HTTP). Набору фильтров можно дать название, как, например ""Только для веб-приложений WebLogic"", и затем выбирать этот фильтр из выпадающего списка фильтров при профилировании приложения, развернутого на сервере WebLogic.

image::images/custom-filter.png[title=""диалоговое окно, которое отображается при профилировании проекта в первый раз""]

Можно задать простой инструментальный фильтр, выбрав ""Быстрый фильтр"" из выпадающего списка фильтров, который откроет диалоговое окно ""Установить быстрый фильтр"". Затем можно быстро изменить список пакетов или классов для инструментирования. Это создаст быстрый фильтр, который затем можно выбирать из выпадающего списка фильтров.

image::images/set-quick-filter.png[title=""диалоговое окно, которое отображается при профилировании проекта в первый раз""]

Более подробную информацию об определении и использовании инструментальных фильтров можно найти в документации по профилированию, поставляемой с IDE.


== Анализ использования памяти приложением

С помощью средства профилирования, встроенного в IDE, можно анализировать, сколько памяти использует корпоративное приложение, чтобы получить подробные данные по размещению объектов и сборке мусора. Задач ""Анализ использования памяти"" предоставляет данные об объектах, выделенных в целевом приложении, таких как число, тип и расположение выделенных объектов.

При профилировании использования памяти нет возможности задать корневой метод профилирования и/или инструментальные фильтры, поэтому отслеживаются все объекты, созданные во время работы сервера. На сложных серверах приложений это может привести к серьезному потреблению памяти и затратам системных ресурсов на профилирование. Поэтому, прежде чем запускать этот тип профилирования, необходимо иметь в виду потенциальные ограничения работы компьютера. Чтобы уменьшить затраты системных ресурсов на профилирование, можно изменить его настройки так, чтобы профилировался только каждый десятый объект. Также можно отключить (ограничить) запись трассировки стеков для размещения объектов.

При профилировании корпоративного приложения для поиска утечек памяти, полезно использовать метрики ""сохранившихся поколений"". Трассировкой числа различных циклов сборки мусора сохранившихся поколений, инструмент профилирования может найти утечку памяти заранее, пока приложение не использовало значительный объем памяти.

Для анализа производительности памяти необходимо выбрать объем данных для получения, выбрав один из следующих вариантов.

* *Быстро.* Если выбран этот вариант, профилировщик создаст образец приложения для предоставления данных, которые ограничены живыми объектами. Живые объекты - все доступные (и недоступные), не востребованные повторно сборщиком мусора (Garbage Collector). Этот параметр отслеживает только живые объекты и не отслеживает распределение при использовании инструментов. Если выбран этот вариант, невозможно регистрировать трассировки стеков или использовать точки профилирования. Этот вариант требует значительно меньших затрат, чем 'Дополнительно'.
* *Дополнительно.* Если выбран этот вариант, можно получить информацию о количестве, типе и местоположении выделенных объектов. Выделенные объекты - это объекты, созданные с момента запуска приложения (или с момента последнего сброса собранных результатов в профилировщике). Все классы, которые в настоящее время загружены целевым JVM (и каждый новый класс после его загрузки) являются инструментами для получения информации о распределении объектов. Этот вариант необходимо выбрать, если нужно использовать точки профилирования при анализе памяти или если нужно выполнить запись стека вызовов. Этот вариант требует больших затрат на профилирование по сравнению с вариантом 'Быстро'.

Если вы выберете вариант 'Дополнительно', вы также можете установить следующие параметры.

* *Запись полного образа жизни объекта.* Выберите этот вариант, чтобы записать всю информацию по каждому объекту, в том числе количество выживших поколений.
* *Запись трассировки стека для распределения.* Выберите этот вариант, чтобы записать полный стек вызовов. Этот вариант позволяет просматривать дерево обратных вызовов для вызовов методов при просмотре снимка памяти.
* *Использование определенных точек профилирования.* Выберите этот вариант, чтобы включить поддержку точек профилирования. Отключенные точки профилирования игнорируются. При отмене этого параметра все точки профилирования в проекте игнорируется.

Измеритель 'Издержки' в окне 'Выбор задачи профилирования' дает приблизительное представление об увеличении или уменьшении издержек на профилирование в соответствии с выбранными параметрами профилирования.

Используем среду IDE для анализа производительности памяти корпоративного приложения. Если необходимо получать информацию о выживших поколениях, необходимо выбрать вариант *Дополнительно*. Кроме того, если необходимы данные только о живых объектах, можно выбрать вариант *Быстро*.

1. Остановите предыдущие сессии профилирования (если они все еще запущены), нажав кнопку ""Завершить"" в окне ""Профилирование"".
При нажатии ""Остановить"" среда IDE отсоединяется от приложения.


. Выберите ""Профиль > Профилировать главный проект"" в главном меню.


. Выберите *Память* в диалоговом окне ""Выбрать задачу профилирования"".


. Выберите *Дополнительно*.


. Выберите *Запись полного жизненного цикла объекта* для получения данных о выживании поколений.

NOTE:  При выборе этого параметра уровень затрат системных ресурсов значительно повысится. При профилировании корпоративного приложения может понадобиться увеличить размер памяти, используемой IDE, из-за количество собранных данных.



. Снимите отметку с параметра *Использовать определенные точки профилирования* (если он был отмечен). Нажмите кнопку ""Выполнить"".

image::images/profile-memory-advanced.png[title=""Диалоговое окно 'Выбрать задачу профилированию', в котором поазывается задача и параметры памяти""]

При нажатии кнопки ""Выполнить"" среда IDE компилирует приложение, запускает сервер в режиме профилирования и разворачивает на нем приложение. Чтобы просмотреть результаты профилирования, нажмите кнопку ""Текущие результаты"" в окне ""Средство профилирования"", при этом откроется окно ""Текущие результаты"". Окно ""Текущие результаты"" показывает информацию о размере и количестве объектов, находящихся на целевой виртуальной машине Java. В дополнение к объектам, размещенным корпоративным приложением, в результатах показываются все объекты, размещенные сервером приложений.

image::images/profile-memory-results.png[title=""Вкладка 'Результаты профилирования', на которой отображаются результаты профилирования использования памяти""]

По умолчанию результаты сохраняются и отображаются как число выделенных байтов, но можно щелкнуть заголовок столбца, чтобы изменить способ отображения результатов. Также можно выполнить фильтрацию результатов, введя имя класса в поле фильтра под списком.

link:/about/contact_form.html?to=3&subject=Feedback:%20Profiling%20Enterprise%20Applications[+Отправить отзыв по этому учебному курсу+]



== Дополнительные сведения

Этот документ описал основной подход к получению данных измерений при профилировании корпоративного приложение, развернутого на сервере приложений GlassFish.

Для получения более подробной информации о параметрах и функциях профилирования, не рассмотренных в этом документе, воспользуйтесь документацией, входящей в состав среды IDE и доступной из меню ""Справка"".

Сопутствующая документация приведена в следующих ресурсах.

* link:http://wiki.netbeans.org/wiki/view/NetBeansUserFAQ#section-NetBeansUserFAQ-Profiler[+Часто задаваемые вопросы по профилированию NetBeans+]
Документ содержит часто задаваемые вопросы по профилированию приложений в среде IDE NetBeans
* link:http://wiki.netbeans.org/wiki/view/FaqProfilerProfileFreeForm[+Часто задаваемые вопросы: профилирование проекта произвольной формы+]
* link:../java/profiler-screencast.html[+Демонстрация: точки профилирования, детализированные графики, анализатор кучи+]
Демонстрация некоторых функций профилирования в среде IDE NetBeans
* link:../../../community/magazine/html/04/profiler.html[+Расширенное профилирование: теория на практике+]
* link:http://profiler.netbeans.org/index.html[+profiler.netbeans.org+]
Сайт проекта средства профилирования NetBeans
* link:http://blogs.oracle.com/nbprofiler/[+Блог по средству профилирования NetBeans+]
* link:http://profiler.netbeans.org/mailinglists.html[+Списки рассылки по средству профилирования NetBeans+]
* link:http://profiler.netbeans.org/docs/help/5.5/index.html[+Использование профилировщика NetBeans, версии 5.5+]

<<top,В начало>>

",12308,True,2573.7749650442524,median
"[[git-plugin]]
= Git Plugin
:toc: macro
:toc-title:

[#introduction]
== Introduction

[.float-group]
--
[.text-center]
image:https://jenkins.io/images/logos/jenkins/jenkins.png[Jenkins logo,height=192,role=center,float=right]
image:images/signe-1923369_640.png[plus,height=64,float=right]
image:https://git-scm.com/images/logos/downloads/Git-Logo-2Color.png[Git logo,height=128,float=right]
--

The git plugin provides fundamental git operations for Jenkins projects.
It can poll, fetch, checkout, branch, list, merge, tag, and push repositories.

toc::[]

[#changelog]
== Changelog in https://github.com/jenkinsci/git-plugin/releases[GitHub Releases]

Release notes are recorded in https://github.com/jenkinsci/git-plugin/releases[GitHub Releases] since July 1, 2019 (git plugin 3.10.1 and later).
Prior release notes are recorded in the git plugin repository link:CHANGELOG.adoc#changelog-moved-to-github-releases[change log].

== Pipelines

The git plugin provides an SCM implementation to be used with the Pipeline SCM link:https://www.jenkins.io/doc/pipeline/steps/workflow-scm-step/[`checkout` step].
The link:https://www.jenkins.io/doc/book/pipeline/getting-started/#snippet-generator[""Pipeline Syntax"" snippet generator] guides the user to select checkout options.

The link:https://youtu.be/ai1kf4ihZUo[90 second video clip] below introduces the Pipeline Syntax snippet generator and shows how it is used to generate steps for the Jenkins Pipeline.

image:images/pipeline-syntax.png[link=https://youtu.be/ai1kf4ihZUo]

=== Multibranch Pipelines

The git plugin includes a multibranch provider for Jenkins link:https://www.jenkins.io/doc/book/pipeline/multibranch/[Multibranch Pipelines] and for Jenkins link:https://www.jenkins.io/doc/book/pipeline/multibranch/#organization-folders[Organization Folders].
The git plugin multibranch provider is a ""base implementation"" that uses command line git.
Users should prefer the multibranch implementation for their git provider when one is available.
Multibranch implementations for specific git providers can use REST API calls to improve the Jenkins experience and add additional capabilities.
Multibranch implementations are available for
link:https://docs.cloudbees.com/docs/cloudbees-ci/latest/cloud-admin-guide/github-branch-source-plugin[GitHub],
link:https://github.com/jenkinsci/bitbucket-branch-source-plugin/blob/master/docs/USER_GUIDE.adoc[Bitbucket],
link:https://plugins.jenkins.io/gitlab-branch-source/[GitLab],
link:https://plugins.jenkins.io/gitea/[Gitea], and
link:https://plugins.jenkins.io/tuleap-git-branch-source/[Tuleap].

The link:https://youtu.be/B_2FXWI6CWg[30 minute video clip] below introduces Multibranch Pipelines.

image:images/multibranch-pipeline.png[link=https://youtu.be/B_2FXWI6CWg]

[#configuration]
== [[GitPlugin-ProjectConfiguration]]Configuration

[#using-repositories]
=== Repositories

image:/images/git-repository-configuration.png[Repository Configuration]

The git plugin fetches commits from one or more remote repositories and performs a checkout in the agent workspace.
Repositories and their related information include:

Repository URL::

  The URL of the remote repository.
  The git plugin passes the remote repository URL to the git implementation (command line or JGit).
  Valid repository URL's include `https`, `ssh`, `scp`, `git`, `local file`, and other forms.
  Valid repository URL forms are described in the link:https://git-scm.com/book/en/v2/Git-on-the-Server-The-Protocols#_the_protocols[git documentation].

Credentials::

  Credentials are defined using the link:https://plugins.jenkins.io/credentials[Jenkins credentials plugin].
  They are selected from a drop-down list and their identifier is stored in the job definition.
  Refer to <<using-credentials,using credentials>> for more details on supported credential types.

Name::

  Git uses a shortname to simplify user references to the URL of the remote repository.
  The default shortname is `origin`.
  Other values may be assigned and then used throughout the job definition to refer to the remote repository.

Refspec::

  A refspec maps remote branches to local references.
  It defines the branches and tags which will be fetched from the remote repository into the agent workspace.
+
A refspec defines the remote references that will be retrieved and how they map to local references.
If left blank, it will default to the normal `git fetch` behavior and will retrieve all branches.
This default behavior is sufficient for most cases.
+
The default refspec is `+refs/heads/*:refs/remotes/REPOSITORYNAME/` where REPOSITORYNAME is the value you specify in the above repository ""Name"" field.
The default refspec retrieves all branches.
If a checkout only needs one branch, then a more restrictive refspec can reduce the data transfer from the remote repository to the agent workspace.
For example, `+refs/heads/master:refs/remotes/origin/master` will retrieve only the master branch and nothing else.
+
The refspec can be used with the <<honor-refspec-on-initial-clone,honor refspec on initial clone>> option in the <<advanced-clone-behaviours,advanced clone behaviors>> to limit the number of remote branches mapped to local references.
If ""honor refspec on initial clone"" is not enabled, then a default refspec for its initial fetch.
This maintains compatibility with previous behavior and allows the job definition to decide if the refspec should be honored on initial clone.
+
Multiple refspecs can be entered by separating them with a space character.
The refspec value `+refs/heads/master:refs/remotes/origin/master +refs/heads/develop:refs/remotes/origin/develop` retrieves the master branch and the develop branch and nothing else.
+
Refer to the link:https://git-scm.com/book/en/v2/Git-Internals-The-Refspec[git refspec documentation] for more refspec details.

[#using-credentials]
=== Using Credentials

The git plugin supports username / password credentials and private key credentials provided by the
https://plugins.jenkins.io/credentials[Jenkins credentials plugin].
It does not support other credential types like secret text, secret file, or certificates.
Select credentials from the job definition drop down menu or enter their identifiers in Pipeline job definitions.

When the remote repository is accessed with the **HTTP or HTTPS protocols**, the plugin requires a **username / password credential**.
Other credential types will not work with HTTP or HTTPS protocols.

When the remote repository is accessed with the **ssh protocol**, the plugin requires an **ssh private key credential**.
Other credential types will not work with the ssh protocol.

[#push-notification-from-repository]
=== [[GitPlugin-Pushnotificationfromrepository]]Push Notification From Repository

To minimize the delay between a push and a build, configure the remote repository to use a Webhook to notify Jenkins of changs to the repository.
Refer to webhook documentation for your repository:

* link:https://plugins.jenkins.io/github#GitHubPlugin-GitHubhooktriggerforGITScmpolling[GitHub]
* link:https://plugins.jenkins.io/bitbucket[Bitbucket]
* link:https://plugins.jenkins.io/gitlab-branch-source[GitLab]
* link:https://github.com/jenkinsci/gitea-plugin/blob/master/docs/README.md[Gitea]

Other git repositories can use a link:https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks[post-receive hook] in the remote repository to notify Jenkins of changes.
Add the following line in your `hooks/post-receive` file on the git server, replacing <URL of the Git repository> with the fully qualified URL you use when cloning the repository.

....
curl http://yourserver/git/notifyCommit?url=<URL of the Git repository>
....

This will scan all the jobs that:

* Have Build Triggers > Poll SCM enabled.  No polling schedule is required.
* Are configured to build the repository at the specified URL

For jobs that meet these conditions, polling will be triggered.
If polling finds a change worthy of a build, a build will be triggered.

This allows a notify script to remain the same for all Jenkins jobs.
Or if you have multiple repositories under a single repository host application (such as Gitosis), you can share a single post-receive hook script with all the repositories.
Finally, this URL doesn't require authentication even for secured Jenkins, because the server doesn't directly use anything that the client is sending.
It polls to verify that there is a change before it actually starts a build.

When notifyCommit is successful, the list of triggered projects is returned.

[#enabling-jgit]
=== Enabling JGit

See the link:https://plugins.jenkins.io/git-client/#enabling-jgit[git client plugin documentation] for instructions to enable JGit.
JGit becomes available throughout Jenkins once it has been enabled.

[#global-configuration]
=== [[GitPlugin-Configuration]]Global Configuration

image:/images/git-global-configuration.png[Global Configuration]

In the `Configure System` page, the Git Plugin provides the following options:

[[global-config-user-name]]
Global Config user.name Value::

  Defines the default git user name that will be assigned when git commits a change from Jenkins.
  For example, `Janice Examplesperson`.
  This can be overridden by individual projects with the <<custom-user-name-e-mail-address>> extension.

[[global-config-user-email]]
Global Config user.email Value::

  Defines the default git user e-mail that will be assigned when git commits a change from Jenkins.
  For example, `janice.examplesperson@example.com`.
  This can be overridden by individual projects with the <<custom-user-name-e-mail-address>> extension.

[[create-new-accounts-based-on-author-email]]
Create new accounts based on author/committer's email::

  New user accounts are created in Jenkins for committers and authors identified in changelogs.
  The new user accounts are added to the internal Jenkins database.
  The e-mail address is used as the id of the account.

[[show-the-entire-commit-summary-in-changes]]
Show the entire commit summary in changes::

  The `changes` page for each job would truncate the change summary prior to git plugin 4.0.
  With the release of git plugin 4.0, the default was changed to show the complete change summary.
  Administrators that want to restore the old behavior may disable this setting.

[[hide-credentials]]
Hide credential usage in job output::

  If checked, the console log will not show the credential identifier used to clone a repository.

[[disable-performance-enhancements]]
Disable performance enhancements::

  If JGit and command line git are both enabled on an agent, the git plugin uses a ""git tool chooser"" to choose a preferred git implementation.
  The preferred git implementation depends on the size of the repository and the git plugin features requested by the job.
  If the repository size is *less than* the JGit repository size threshold and the git features of the job are all implmented in JGit, then JGit is used.
  If the repository size is *greater than* the JGit repository size threshold or the job requires git features that are not implemented in JGit, then command line git is used.
+
If checked, the plugin will disable the feature that recommends a git implementation on the basis of the size of a repository.
This switch may be used in case of a bug in the performance improvement feature.
If you enable this setting, please report a git plugin issue that describes why you needed to enable it.

[[preserve-second-fetch-during-checkout]]
Preserve second fetch during initial checkout::

  If checked, the initial checkout step will not avoid the second fetch.
  Git plugin versions prior to git plugin 4.4 would perform two fetch operations during the initial repository checkout.
  Git plugin 4.4 removes the second fetch operation in most cases.
  Enabling this option will restore the second fetch operation.
  This setting is only needed if there is a bug in the redundant fetch removal logic.
  If you enable this setting, please report a git plugin issue that describes why you needed to enable it.

[[do-not-add-git-tag-action-to-jobs]]
Add git tag action to jobs::

  If checked, the git tag action will be added to any builds that happen *after* the box is checked.
  Prior to git plugin 4.5.0, the git tag action was always added.
  Git plugin 4.5.0 and later will not add the git tag action to new builds unless the administrator enables it.
+
The git tag action allows a user to apply a tag to the git repository in the workspace based on the git commit used in the build applying the tag.
The git plugin does *not* push the applied tag to any other location.
If the workspace is removed, the tag that was applied is lost.
Tagging a workspace made sense when using centralized repositories that automatically applied the tag to the centralized repository.
Applying a git tag in an agent workspace doesn't have many practical uses.

[#repository-browser]
=== Repository Browser

image:/images/git-repository-browser.png[Repository Browser]

A Repository Browser adds links in ""changes"" views within Jenkins to an external system for browsing the details of those changes.
The ""Auto"" selection attempts to infer the repository browser from the ""Repository URL"" and can detect cloud versions of GitHub, Bitbucket and GitLab.

Repository browsers include:

[#assemblaweb-repository-browser]
==== AssemblaWeb

image:/images/git-repository-browser-assemblaweb.png[Assembla Repository Browser]

Repository browser for git repositories hosted by link:https://www.assembla.com/home[Assembla].
Options include:

[[assembla-git-url]]
Assembla Git URL::

  Root URL serving this Assembla repository.
  For example, `\\https://app.assembla.com/spaces/git-plugin/git/source`

[#fisheye-repository-browser]
==== FishEye

image:/images/git-repository-browser-fisheye.png[FishEye Repository Browser]

Repository browser for git repositories hosted by link:https://www.atlassian.com/software/fisheye[Atlassian Fisheye].
Options include:

[[fisheye-url]]
URL::

  Root URL serving this FishEye repository.
  For example, `\\https://fisheye.example.com/browser/my-project`

[#kiln-repository-browser]
==== Kiln

image:/images/git-repository-browser-kiln.png[Kiln Repository Browser]

Repository browser for git repositories hosted by link:http://www.fogbugz.com/version-control[Kiln].
Options include:

[[kiln-url]]
URL::

  Root URL serving this Kiln repository.
  For example, `\\https://kiln.example.com/username/my-project`

[#visual-studio-team-services-repository-browser]
==== Microsoft Team Foundation Server/Visual Studio Team Services

image:/images/git-repository-browser-microsoft.png[Microsoft Repository Browser]

Repository browser for git repositories hosted by link:https://azure.microsoft.com/en-us/solutions/devops/[Azure DevOps].
Options include:

[[visual-studio-repository-url-or-name]]
URL or name::

  Root URL serving this Azure DevOps repository.
  For example, `\\https://example.visualstudio.com/_git/my-project.`

[bitbucketweb-repository-browser]
==== bitbucketweb

image:/images/git-repository-browser-bitbucket.png[Bitbucket Repository Browser]

Repository browser for git repositories hosted by link:https://bitbucket.org/[Bitbucket].
Options include:

[[bitbucketweb-url]]
URL::

  Root URL serving this Bitbucket repository.
  For example, `\\https://bitbucket.example.com/username/my-project`

[#cgit-repository-browser]
==== cgit

image:/images/git-repository-browser-cgit.png[CGit Repository Browser]

Repository browser for git repositories hosted by link:https://git.zx2c4.com/cgit/[cgit].
Options include:

[[cgit-url]]
URL::

  Root URL serving this cgit repository.
  For example, `\\https://git.zx2c4.com/cgit/`

[#gitblit-repository-browser]
==== gitblit

image:/images/git-repository-browser-gitblit.png[GitBlit Repository Browser]

[[gitblit-url]]
GitBlit root url::

  Root URL serving this GitBlit repository.
  For example, `\\https://gitblit.example.com/`

[[gitblit-project-name]]
Project name in GitBlit::

  Name of the GitBlit project.
  For example, `my-project`

[#githubweb-repository-browser]
==== githubweb

image:/images/git-repository-browser-github.png[GitHub Repository Browser]

Repository browser for git repositories hosted by link:https://github.com//[GitHub].
Options include:

[[githubweb-url]]
URL::

  Root URL serving this GitHub repository.
  For example, `\\https://github.example.com/username/my-project`

[#gitiles-repository-browser]
==== gitiles

image:/images/git-repository-browser-gitiles.png[Gitiles Repository Browser]

Repository browser for git repositories hosted by link:https://gerrit.googlesource.com/gitiles/[Gitiles].
Options include:

[[githubweb-url]]
gitiles root url::

  Root URL serving this Gitiles repository.
  For example, `\\https://gerrit.googlesource.com/gitiles/`

[#gitlab-self-hosted-repository-browser]
[#gitlab-com-repository-browser]
==== gitlab

image:/images/git-repository-browser-gitlab.png[GitLab Repository Browser]

Repository browser for git repositories hosted by link:https://gitlab.com/[GitLab].
Options include:

[[gitlab-url]]
URL::

  Root URL serving this GitLab repository.
  For example, `\\https://gitlab.example.com/username/my-project`

[[gitlab-version]]
Version::

  Major and minor version of GitLab you use, such as 12.6.
  If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
  For example, `12.6`

[#gitlist-repository-browser]
==== gitlist

image:/images/git-repository-browser-gitlist.png[Gitlist Repository Browser]

Repository browser for git repositories hosted by link:https://gitlist.org/[GitList].
Options include:

[[gitlist-url]]
URL::

  Root URL serving this GitList repository.
  For example, `\\https://gitlist.example.com/username/my-project`

[#gitoriousweb-repository-browser]
==== gitoriousweb

Gitorious was acquired in 2015.
This browser is *deprecated*.

[[gitoriousweb-url]]
URL::

  Root URL serving this Gitorious repository.
  For example, `\\https://gitorious.org/username/my-project`

[#gitweb-repository-browser]
==== gitweb

image:/images/git-repository-browser-gitweb.png[Gitweb Repository Browser]

Repository browser for git repositories hosted by link:https://git-scm.com/docs/gitweb[GitWeb].
Options include:

[[gitweb-url]]
URL::

  Root URL serving this GitWeb repository.
  For example, `\\https://gitweb.example.com/username/my-project`

[#gogs-repository-browser]
==== gogs

image:/images/git-repository-browser-gogs.png[Gogs Repository Browser]

Repository browser for git repositories hosted by link:https://gogs.io/[Gogs].
Options include:

[[gogs-url]]
URL::

  Root URL serving this Gogs repository.
  For example, `\\https://gogs.example.com/username/my-project`

[#phabricator-repository-browser]
==== phabricator

image:/images/git-repository-browser-phabricator.png[Phabricator Repository Browser]

Repository browser for git repositories hosted by link:https://www.phacility.com/phabricator/[Phacility Phabricator].
Options include:

[[phabricator-url]]
URL::

  Root URL serving this Phabricator repository.
  For example, `\\https://phabricator.example.com/`

[[phabricator-repository-name]]
Repository name in Phab::

  Name of the Phabricator repository.
  For example, `my-project`

[#redmineweb-repository-browser]
==== redmineweb

image:/images/git-repository-browser-redmine.png[Redmine Repository Browser]

Repository browser for git repositories hosted by link:https://www.redmine.org/[Redmine].
Options include:

[[redmineweb-url]]
URL::

  Root URL serving this Redmine repository.
  For example, `\\https://redmine.example.com/username/projects/my-project/repository`

[#rhodecode-repository-browser]
==== rhodecode

image:/images/git-repository-browser-rhodecode.png[RhodeCode Repository Browser]

Repository browser for git repositories hosted by link:https://thodecode.com/[RhodeCode].
Options include:

[[rhodecode-url]]
URL::

  Root URL serving this RhodeCode repository.
  For example, `\\https://rhodecode.example.com/username/my-project`

[#stash-repository-browser]
==== stash

image:/images/git-repository-browser-stash.png[Stash Repository Browser]

Stash is now called *BitBucket Server*.
Repository browser for git repositories hosted by link:https://www.atlassian.com/software/bitbucket[BitBucket Server].
Options include:

[[stash-url]]
URL::

  Root URL serving this Stash repository.
  For example, `\\https://stash.example.com/username/my-project`

[#viewgit-repository-browser]
==== viewgit

image:/images/git-repository-browser-viewgit.png[Viewgit Repository Browser]

Repository browser for git repositories hosted by link:https://www.openhub.net/p/viewgit[viewgit].
Options include:

[[viewgit-root-url]]
ViewGit root url::

  Root URL serving this ViewGit repository.
  For example, `\\https://viewgit.example.com/`

[[viewgit-project-name]]
Project Name in ViewGit::

  ViewGit project name.
  For example, `my-project`

[#extensions]
== Extensions

Extensions add new behavior or modify existing plugin behavior for different uses.
Extensions help users more precisely tune the plugin to meet their needs.

Extensions include:

- <<clone-extensions>>
- <<checkout-extensions>>
- <<changelog-extensions>>
- <<tagging-extensions>>
- <<build-initiation-extensions>>
- <<merge-extensions>>
- <<deprecated-extensions>>

[#clone-extensions]
=== Clone Extensions

Clone extensions modify the git operations that retrieve remote changes into the agent workspace.
The extensions can adjust the amount of history retrieved, how long the retrieval is allowed to run, and other retrieval details.

[#advanced-clone-behaviours]
==== Advanced clone behaviours

image:/images/git-advanced-clone-behaviours.png[Advanced clone behaviours]

Advanced clone behaviors modify the `link:https://git-scm.com/docs/git-clone[git clone]` and `link:https://git-scm.com/docs/git-fetch[git fetch]` commands.
They control:

* breadth of history retrieval (refspecs)
* depth of history retrieval (shallow clone)
* disc space use (reference repositories)
* duration of the command (timeout)
* tag retrieval

Advanced clone behaviors include:

[[honor-refspec-on-initial-clone]]
Honor refspec on initial clone::

  Perform initial clone using the refspec defined for the repository.
  This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
  If this is not enabled, then the plugin default refspec includes **all** remote branches.

Shallow clone::

  Perform a shallow clone by requesting a limited number of commits from the tip of the requested branch(es).
  Git will not download the complete history of the project.
  This can save time and disk space when you just want to access the latest version of a repository.

Shallow clone depth::

  Set shallow clone depth to the specified number of commits.
  Git will only download `depth` commits from the remote repository, saving time and disk space.

Path of the reference repo to use during clone::

  Specify a folder containing a repository that will be used by git as a reference during clone operations.
  This option will be ignored if the folder is not available on the agent.

Timeout (in minutes) for clone and fetch operations::

  Specify a timeout (in minutes) for clone and fetch operations.

Fetch tags::

  Deselect this to perform a clone without tags, saving time and disk space when you want to access only what is specified by the refspec, without considering any repository tags.

[#prune-stale-remote-tracking-branches]
==== Prune stale remote tracking branches

image:/images/git-prune-stale-remote-tracking-branches.png[Prune stale remote tracking branches]

Removes remote tracking branches from the local workspace if they no longer exist on the remote.
See `link:https://git-scm.com/docs/git-remote#Documentation/git-remote.txt-empruneem[git remote prune]` and `link:https://git-scm.com/docs/git-fetch#_pruning[git fetch --prune]` for more details.

[#prune-stale-tags]
==== Prune stale tags

image:/images/git-prune-stale-tags.png[Prune stale tags]

Removes tags from the local workspace before fetch if they no longer exist on the remote.
If stale tags are not pruned, deletion of a remote tag will not remove the local tag in the workspace.
If the local tag already exists in the workspace, git correctly refuses to create the tag again.
Pruning stale tags allows the local workspace to create a tag with the same name as a tag which was removed from the remote.

[#checkout-extensions]
=== Checkout Extensions

Checkout extensions modify the git operations that place files in the workspace from the git repository on the agent.
The extensions can adjust the maximum duration of the checkout operation, the use and behavior of git submodules, the location of the workspace on the disc, and more.

[#advanced-checkout-behaviors]
==== Advanced checkout behaviors

image:/images/git-advanced-checkout-behaviors.png[Advanced checkout behaviors]

Advanced checkout behaviors modify the `link:https://git-scm.com/docs/git-checkout[git checkout]` command.
Advanced checkout behaviors include

Timeout (in minutes) for checkout operation::

  Specify a timeout (in minutes) for checkout.
  The checkout is stopped if the timeout is exceeded.
  Checkout timeout is usually only required with slow file systems or large repositories.

[#advanced-sub-modules-behaviours]
==== Advanced sub-modules behaviours

image:/images/git-advanced-sub-modules-behaviours.png[Advanced sub-modules behaviours]

Advanced sub-modules behaviors modify the `link:https://git-scm.com/docs/git-submodule[git submodule]` commands.
They control:

* depth of history retrieval (shallow clone)
* disc space use (reference repositories)
* credential use
* duration of the command (timeout)
* concurrent threads used to fetch submodules

Advanced sub-modules include:

Disable submodules processing::

  Ignore submodules in the repository.

Recursively update submodules::

  Retrieve all submodules recursively. Without this option, submodules
  which contain other submodules will ignore the contained submodules.

Update tracking submodules to tip of branch::

  Retrieve the tip of the configured branch in .gitmodules.

Use credentials from default remote of parent repository::

  Use credentials from the default remote of the parent project.
  Submodule updates do not use credentials by default.
  Enabling this extension will provide the parent repository credentials to each of the submodule repositories.
  Submodule credentials require that the submodule repository must accept the same credentials as the parent project.
  If the parent project is cloned with https, then the authenticated submodule references must use https as well.
  If the parent project is cloned with ssh, then the authenticated submodule references must use ssh as well.

Path of the reference repo to use during submodule update::

  Folder containing a repository that will be used by git as a reference during submodule clone operations.
  This option will be ignored if the folder is not available on the agent running the build.
  A reference repository may contain multiple subprojects.
  See the combining repositories section for more details.

Timeout (in minutes) for submodule operations::

  Specify a timeout (in minutes) for submodules operations.
  This option overrides the default timeout.

Number of threads to use when updating submodules::

  Number of parallel processes to be used when updating submodules.
  Default is to use a single thread for submodule updates

Shallow clone::

  Perform shallow clone of submodules.
  Git will not download the complete history of the project, saving time and disk space.

Shallow clone depth::

  Set shallow clone depth for submodules.
  Git will only download recent history of the project, saving time and disk space.

[#checkout-to-a-sub-directory]
==== Checkout to a sub-directory

image:/images/git-checkout-to-a-sub-directory.png[Checkout to a sub-directory]

Checkout to a subdirectory of the workspace instead of using the workspace root.

This extension should **not** be used in Jenkins Pipeline (either declarative or scripted).
Jenkins Pipeline already provides standard techniques for checkout to a subdirectory.
Use `ws` and `dir` in Jenkins Pipeline rather than this extension.

Local subdirectory for repo::

  Name of the local directory (relative to the workspace root) for the git repository checkout.
  If left empty, the workspace root itself will be used.

[#checkout-to-specific-local-branch]
==== Checkout to specific local branch

image:/images/git-checkout-to-specific-local-branch.png[Checkout to specific local branch]

Branch name::

  If given, checkout the revision to build as HEAD on the named branch.
  If value is an empty string or ""**"", then the branch name is computed from the remote branch without the origin.
  In that case, a remote branch 'origin/master' will be checked out to a local branch named 'master', and a remote branch 'origin/develop/new-feature' will be checked out to a local branch named 'develop/new-feature'.
  If a specific revision and not branch HEAD is checked out, then 'detached' will be used as the local branch name.

[#wipe-out-repository-and-force-clone]
==== Wipe out repository and force clone

image:/images/git-wipe-out-repository-and-force-clone.png[Wipe out repository and force clone]

Delete the contents of the workspace before build and before checkout.
Deletes the git repository inside the workspace and will force a full clone.

[clean-after-checkout]
==== Clean after checkout

image:/images/git-clean-after-checkout.png[Clean after checkout]

Clean the workspace *after* every checkout by deleting all untracked files and directories, including those which are specified in `.gitignore`.
Resets all tracked files to their versioned state.
Ensures that the workspace is in the same state as if clone and checkout were performed in a new workspace.
Reduces the risk that current build will be affected by files generated by prior builds.
Does not remove files outside the workspace (like temporary files or cache files).
Does not remove files in the `.git` repository of the workspace.

Delete untracked nested repositories::

  Remove subdirectories which contain `.git` subdirectories if this option is enabled.
  This is implemented in command line git as `git clean -xffd`.
  Refer to the link:https://git-scm.com/docs/git-clean[git clean manual page] for more information.

[#clean-before-checkout]
==== Clean before checkout

image:/images/git-clean-before-checkout.png[Clean before checkout]

Clean the workspace *before* every checkout by deleting all untracked files and directories, including those which are specified in .gitignore.
Resets all tracked files to their versioned state.
Ensures that the workspace is in the same state as if cloned and checkout were performed in a new workspace.
Reduces the risk that current build will be affected by files generated by prior builds.
Does not remove files outside the workspace (like temporary files or cache files).
Does not remove files in the `.git` repository of the workspace.

Delete untracked nested repositories::

  Remove subdirectories which contain `.git` subdirectories if this option is enabled.
  This is implemented in command line git as `git clean -xffd`.
  Refer to the link:https://git-scm.com/docs/git-clean[git clean manual page] for more information.

[#sparse-checkout-paths]
==== Sparse checkout paths

image:/images/git-sparse-checkout-paths.png[Sparse checkout paths]

Specify the paths that you'd like to sparse checkout.
This may be used for saving space (Think about a reference repository).
Be sure to use a recent version of Git, at least above 1.7.10.

Multiple sparse checkout path values can be added to a single job.

Path::

  File or directory to be included in the checkout

[#git-lfs-pull-after-checkout]
==== Git LFS pull after checkout

image:/images/git-lfs-pull-after-checkout.png[Git LFS pull after checkout]

Enable https://git-lfs.github.com/[git large file support] for the workspace by pulling large files after the checkout completes.
Requires that the controller and each agent performing an LFS checkout have installed `git lfs`.

[#changelog-extensions]
=== Changelog Extensions

The plugin can calculate the source code differences between two builds.
Changelog extensions adapt the changelog calculations for different cases.

[#calculate-changelog-against-a-specific-branch]
==== Calculate changelog against a specific branch

image:/images/git-calculate-changelog-against-a-specific-branch.png[Calculate changelog against a specific branch]

'Calculate changelog against a specific branch' uses the specified branch to compute the changelog instead of computing it based on the previous build.
This extension can be useful for computing changes related to a known base branch, especially in environments which do not have the concept of a ""pull request"".

Name of repository::

  Name of the repository, such as 'origin', that contains the branch.

Name of branch::

  Name of the branch used for the changelog calculation within the named repository.

[#use-commit-author-in-changelog]
==== Use commit author in changelog

image:/images/git-use-commit-author-in-changelog.png[Use commit author in changelog]

The default behavior is to use the Git commit's ""Committer"" value in build changesets.
If this option is selected, the git commit's ""Author"" value is used instead.

[#tagging-extensions]
=== Tagging Extensions

[#create-a-tag-for-every-build]
==== Create a tag for every build

image:/images/git-create-a-tag-for-every-build.png[Create a tag for every build]

Create a tag in the workspace for every build to unambiguously mark the commit that was built.
You can combine this with Git publisher to push the tags to the remote repository.

[#build-initiation-extensions]
=== Build Initiation Extensions

The git plugin can start builds based on many different conditions.
The build inititation extensions control the conditions that start a build.
They can ignore notifications of a change or force a deeper evaluation of the commits when polling

[#dont-trigger-a-build-on-commit-notifications]
==== Don't trigger a build on commit notifications

image:/images/git-do-not-trigger-a-build-on-commit-notifications.png[Do not trigger a build on commit notifications]

If checked, this repository will be ignored when the notifyCommit URL is accessed whether the repository matches or not.

[#force-polling-using-workspace]
==== Force polling using workspace

image:/images/git-force-polling-using-workspace.png[Force polling using workspace]

The git plugin polls remotely using `ls-remote` when configured with a single branch (no wildcards!).
When this extension is enabled, the polling is performed from a cloned copy of the workspace instead of using `ls-remote`.

If this option is selected, polling will use a workspace instead of using `ls-remote`.

By default, the plugin polls by executing a polling process or thread on the Jenkins master.
If the Jenkins controller does not have a git installation, the administrator may <<enabling-jgit,enable JGit>> to use a pure Java git implementation for polling.
In addition, the administrator may need to <<GitPlugin-WhyNotJGit,disable command line git>> to prevent use of command line git on the Jenkins master.

[#polling-ignores-commits-from-certain-users]
==== Polling ignores commits from certain users

image:/images/git-polling-ignores-commits-from-certain-users.png[Polling ignores commits from certain users]

These options allow you to perform a merge to a particular branch before building.
For example, you could specify an integration branch to be built, and to merge to master.
In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful.
It then may push the merge back to the remote repository if the Git Push post-build action is selected.

Excluded Users::

  If set and Jenkins is configured to poll for changes, Jenkins will ignore any revisions committed by users in this list when determining if a build should be triggered.
  This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct SCM user.
  Using this behavior prevents the faster `git ls-remote` polling mechanism.
  It forces polling to require a workspace, as if you had selected the <<force-polling-using-workspace,Force polling using workspace>> extension.

  Each exclusion uses exact string comparison and must be separated by a new line.
  User names are only excluded if they exactly match one of the names in this list.

[#polling-ignores-commits-in-certain-paths]
==== Polling ignores commits in certain paths

image:/images/git-polling-ignores-commits-in-certain-paths.png[Polling ignores commits in certain paths]

If set and Jenkins is configured to poll for changes, Jenkins will pay attention to included and/or excluded files and/or folders when determining if a build needs to be triggered.

Using this behavior will preclude the faster remote polling mechanism, forcing polling to require a workspace thus sometimes triggering unwanted builds, as if you had selected the <<force-polling-using-workspace,Force polling using workspace>> extension as well.
This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct SCM user.
Using this behavior will preclude the faster git ls-remote polling mechanism, forcing polling to require a workspace, as if you had selected the <<force-polling-using-workspace,Force polling using workspace>> extension as well.

Included Regions::

  Each inclusion uses java regular expression pattern matching, and must be separated by a new line.
  An empty list implies that everything is included.

Excluded Regions::

  Each exclusion uses java regular expression pattern matching, and must be separated by a new line.
  An empty list excludes nothing.

[#polling-ignores-commits-with-certain-messages]
==== Polling ignores commits with certain messages

image:/images/git-polling-ignores-commits-with-certain-messages.png[Polling ignores commits with certain messages]

Excluded Messages::

  If set and Jenkins is set to poll for changes, Jenkins will ignore any revisions committed with message matched to the regular expression pattern when determining if a build needs to be triggered.
  This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct message.
  You can create more complex patterns using embedded flag expressions.

[#strategy-for-choosing-what-to-build]
==== Strategy for choosing what to build

image:/images/git-strategy-for-choosing-what-to-build.png[Strategy for choosing what to build]

When you are interested in using a job to build multiple branches, you can choose how Jenkins chooses the branches to build and the order they should be built.

This extension point in Jenkins is used by many other plugins to control the job as it builds specific commits.
When you activate those plugins, you may see them installing a custom build strategy.

Ancestry::

Maximum Age of Commit::

  The maximum age of a commit (in days) for it to be built.
  This uses the GIT_COMMITTER_DATE, not GIT_AUTHOR_DATE

Commit in Ancestry::

  If an ancestor commit (SHA-1) is provided, only branches with this commit in their history will be built.

Default::

  Build all the branches that match the branch name pattern.

Inverse::

  Build all branches except for those which match the branch specifiers configure above.
  This is useful, for example, when you have jobs building your master and various release branches and you want a second job which builds all new feature branches.
  For example, branches which do not match these patterns without redundantly building master and the release branches again each time they change.

[#merge-extensions]
=== Merge Extensions

The git plugin can optionally merge changes from other branches into the current branch of the agent workspace.
Merge extensions control the source branch for the merge and the options applied to the merge.

[#merge-before-build]
==== Merge before build

image:/images/git-merge-before-build.png[Merge before build]

These options allow you to perform a merge to a particular branch before building.
For example, you could specify an integration branch to be built, and to merge to master.
In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful.
It then may push the merge back to the remote repository if the <<publisher-push-merge-results,Git Publisher post-build action>> is selected.

Name of repository::

  Name of the repository, such as origin, that contains the branch. If
  left blank, it'll default to the name of the first repository
  configured.

Branch to merge to::

  The name of the branch within the named repository to merge to, such as
  master.

Merge strategy::

  Merge strategy selection. Choices include:

* default
* resolve
* recursive
* octopus
* ours
* subtree
* recursive_theirs

Fast-forward mode::

* `--ff`: fast-forward which gracefully falls back to a merge commit when required
* `-ff-only`: fast-forward without any fallback
* `--no-ff`: merge commit always, even if a fast-forward would have been allowed

[#custom-user-name-e-mail-address]
==== Custom user name/e-mail address

image:/images/git-custom-user-name-e-mail-address.png[Custom user name/e-mail address]

user.name::

  Defines the user name value which git will assign to new commits made in the workspace.
  If given, the environment variables `GIT_COMMITTER_NAME` and `GIT_AUTHOR_NAME` are set for builds and override values from the global settings.

user.email::

  Defines the user email value which git will assign to new commits made in the workspace.
  If given, the environment variables `GIT_COMMITTER_EMAIL` and `GIT_AUTHOR_EMAIL` are set for builds and override values from the global settings.

[#deprecated-extensions]
=== Deprecated Extensions

[#custom-scm-name---deprecated]
==== Custom SCM name - *Deprecated*

Unique name for this SCM.
Was needed when using Git within the Multi SCM plugin.
Pipeline is the robust and feature-rich way to checkout from multiple repositories in a single job.

[#submodule-combinator---removed]
==== Submodule Combinator - *Removed*

An experiment was created many years ago that attempted to create combinations of submodules within the Jenkins job.
The experiment was never available to Freestyle projects or other legacy projects like multi-configuration projects.
It was visible in Pipeline, configuration as code, and JobDSL.

The implementation of the experiment has been removed.
Dependabot and other configuration tools are better suited to evaluate submodule combinations.

There are no known uses of the submodule combinator and no open Jira issues reported against the submodule combinator.
Those who were using submodule combinator should remain with git plugin versions prior to 4.6.0.

The submodule combinator ignores any user provided value of the following arguments to git's `checkout scm`:

doGenerateSubmoduleConfigurations::

  A boolean that is now always set to `false`.
  Submodule configurations are no longer evaluated by the git plugin.

submoduleCfg::

  A list of submodule names and branches that is now always empty.
  Submodule configurations are no longer evaluated by the git plugin.

Previous Pipeline syntax looked like this:

```groovy
checkout([$class: 'GitSCM',
          branches: [[name: 'master']],
          doGenerateSubmoduleConfigurations: false,
          extensions: [],
          submoduleCfg: [],
          userRemoteConfigs: [[url: 'https://github.com/jenkinsci/git-plugin']]])
```

Current Pipeline Syntax looks like this:

```groovy
checkout([$class: 'GitSCM',
          branches: [[name: 'master']],
          extensions: [],
          userRemoteConfigs: [[url: 'https://github.com/jenkinsci/git-plugin']]])
```

[#environment-variables]
== Environment Variables

The git plugin assigns values to environment variables in several contexts.
Environment variables are assigned in Freestyle, Pipeline, Multibranch Pipeline, and Organization Folder projects.

[#branch-variables]
=== Branch Variables

GIT_BRANCH:: Name of branch being built including remote name, as in `origin/master`
GIT_LOCAL_BRANCH:: Name of branch being built without remote name, as in `master`

[#commit-variables]
=== Commit Variables

GIT_COMMIT:: SHA-1 of the commit used in this build
GIT_PREVIOUS_COMMIT:: SHA-1 of the commit used in the preceding build of this project
GIT_PREVIOUS_SUCCESSFUL_COMMIT:: SHA-1 of the commit used in the most recent successful build of this project

[#system-configuration-variables]
=== System Configuration Variables

GIT_URL:: Remote URL of the first git repository in this workspace
GIT_URL_n:: Remote URL of the additional git repositories in this workspace (if any)
GIT_AUTHOR_EMAIL:: Author e-mail address that will be used for **new commits in this workspace**
GIT_AUTHOR_NAME:: Author name that will be used for **new commits in this workspace**
GIT_COMMITTER_EMAIL:: Committer e-mail address that will be used for **new commits in this workspace***
GIT_COMMITTER_NAME:: Committer name that will be used for **new commits in this workspace**

[#properties]
== Properties

Some git plugin settings can only be controlled from command line properties set at Jenkins startup.

[#default-timeout]
=== Default Timeout

The default git timeout value (in minutes) can be overridden by the `org.jenkinsci.plugins.gitclient.Git.timeOut` property (see https://issues.jenkins-ci.org/browse/JENKINS-11286[JENKINS-11286]).
The property should be set on the controller and on all agents to have effect (see https://issues.jenkins-ci.org/browse/JENKINS-22547[JENKINS-22547]).

[[GitPlugin-WhyNotJGit]]
Command line git is the reference git implementation in the git plugin and the git client plugin.
Command line git provides the most functionality and is the most stable implementation.
Some installations may not want to install command line git and may want to disable the command line git implementation.
Administrators may disable command line git with the property `org.jenkinsci.plugins.gitclient.Git.useCLI=false`.

[#git-publisher]
== Git Publisher

The Jenkins git plugin provides a ""git publisher"" as a post-build action.
The git publisher can push commits or tags from the workspace of a Freestyle project to the remote repository.

The git publisher is **only available** for Freestyle projects.
It is **not available** for Pipeline, Multibranch Pipeline, Organization Folder, or any other job type other than Freestyle.

[#git-publisher-options]
=== Git Publisher Options

The git publisher behaviors are controlled by options that can be configured as part of the Jenkins job.
Options include;

Push Only If Build Succeeds::

  Only push changes from the workspace to the remote repository if the build succeeds.
  If the build status is unstable, failed, or canceled, the changes from the workspace will not be pushed.

[[publisher-push-merge-results]]
Merge Results::

  If pre-build merging is configured through one of the <<merge-extensions,merge extensions>>, then enabling this checkbox will push the merge to the remote repository.

[[publisher-tag-force-push]]
Force Push::

  Git refuses to replace a remote commit with a different commit.
  This prevents accidental overwrite of new commits on the remote repository.
  However, there may be times when overwriting commits on the remote repository is acceptable and even desired.
  If the commits from the local workspace should overwrite commits on the remote repository, enable this option.
  It will request that the remote repository destroy history and replace it with history from the workspace.

[#git-publisher-tags-options]
==== Git publisher tags options

The git publisher can push tags from the workspace to the remote repository.
Options in this section will allow the plugin to create a new tag.
Options will also allow the plugin to update an existing tag, though the link:https://git-scm.com/docs/git-tag#_on_re_tagging[git documentation] **strongly advises** against updating tags.

Tag to push::

  Name of the tag to be pushed from the local workspace to the remote repository.
  The name may include link:https://jenkins.io/doc/book/pipeline/jenkinsfile/#using-environment-variables[Jenkins environment variables] or may be a fixed string.
  For example, the tag to push might be `$BUILD_TAG`, `my-tag-$BUILD_NUMBER`, `build-$BUILD_NUMBER-from-$NODE_NAME`, or `a-very-specific-string-that-will-be-used-once`.

Tag message::

  If the option is selected to create a tag or update a tag, then this message will be associated with the tag that is created.
  The message will expand references to link:https://jenkins.io/doc/book/pipeline/jenkinsfile/#using-environment-variables[Jenkins environment variables].
  For example, the message `Build $BUILD_NUMBER tagged on $NODE_NAME` will use the message `Build 1 tagged on master` if build 1 of the job runs on the master.

Create new tag::

  Create a new tag in the workspace.
  The git publisher will fail the job if the tag already exists.

Update new tag::

  Modify existing tag in the workspace so that it points to the most recent commit.
  Many git repository hosting services will reject attempts to push a tag which has been modified to point to a different commit than its original commit.
  Refer to <<publisher-tag-force-push,force push>> for an option which may force the remote repository to accept a modified tag.
  The link:https://git-scm.com/docs/git-tag#_on_re_tagging[git documentation] **strongly advises against updating tags**.

Tag remote name::

  Git uses the 'remote name' as a short string replacement for the full URL of the remote repository.
  This option defines which remote should receive the push.
  This is typically `origin`, though it could be any one of the remote names defined when the plugin performs the checkout.

[#git-publisher-branches-options]
==== Git publisher branches options

The git publisher can push branches from the workspace to the remote repository.
Options in this section will allow the plugin to push the contents of a local branch to the remote repository.

Branch to push::

  The name of the remote branch that will receive the latest commits from the agent workspace.
  This is usually the same branch that was used for the checkout

Target remote name::

  The shortname of the remote that will receive the latest commits from the agent workspace.
  Usually this is `origin`.
  It needs to be a shortname that is defined in the agent workspace, either through the initial checkout or through later configuration.

Rebase before push::

  Some Jenkins jobs may be blocked from pushing changes to the remote repository because the remote repository has received new commits since the start of the job.
  This may happen with projects that receive many commits or with projects that have long running jobs.
  The `Rebase before push` option fetches the most recent commits from the remote repository, applies local changes over the most recent commits, then pushes the result.
  The plugin uses `git rebase` to apply the local changes over the most recent remote changes.
+
Because `Rebase before push` is modifying the commits in the agent workspace **after the job has completed**, it is creating a configuration of commits that has **not been evaluated by any Jenkins job**.
The commits in the local workspace have been evaluated by the job.
The most recent commits from the remote repository have not been evaluated by the job.
Users may find that the risk of pushing an untested configuration is less than the risk of delaying the visibility of the changes which have been evaluated by the job.

[#combining-repositories]
== Combining repositories

A single reference repository may contain commits from multiple repositories.
For example, if a repository named `parent` includes references to submodules `child-1` and `child-2`, a reference repository could be created to cache commits from all three repositories using the commands:

....
$ mkdir multirepository-cache.git
$ cd  multirepository-cache.git
$ git init --bare
$ git remote add parent https://github.com/jenkinsci/git-plugin
$ git remote add child-1 https://github.com/jenkinsci/git-client-plugin
$ git remote add child-2 https://github.com/jenkinsci/platformlabeler-plugin
$ git fetch --all
....

Those commands create a single bare repository with the current commits from all three repositories.
If that reference repository is used in the advanced clone options link:#clone-reference-repository-path[clone reference repository], it will reduce data transfer and disc use for the parent repository.
If that reference repository is used in the submodule options link:#submodule-reference-repository-path[clone reference repository], it will reduce data transfer and disc use for the submodule repositories.

[#bug-reports]
== Bug Reports

Report issues and enhancements in the
https://issues.jenkins-ci.org[Jenkins issue tracker].

[#contributing-to-the-plugin]
== Contributing to the Plugin

Refer to link:CONTRIBUTING.adoc#contributing-to-the-git-plugin[contributing to the plugin] for contribution guidelines.
Refer to link:Priorities.adoc#git-plugin-development-priorities[plugin development priorities] for the prioritized list of development topics.

== Remove Git Plugin BuildsByBranch BuildData Script

This script is used to remove the static list of BuildsByBranch that is stored for each build by the Git Plugin.

This is a workaround for link:https://issues.jenkins-ci.org/browse/JENKINS-19022[JENKINS-19022]

[source,groovy]
----
import hudson.matrix.*
import hudson.model.*

hudsonInstance = hudson.model.Hudson.instance
jobNames = hudsonInstance.getJobNames()
allItems = []
for (name in jobNames) {
  allItems += hudsonInstance.getItemByFullName(name)
}

// Iterate over all jobs and find the ones that have a hudson.plugins.git.util.BuildData
// as an action.
//
// We then clean it by removing the useless array action.buildsByBranchName
//

for (job in allItems) {
  println(""job: "" + job.name);
  def counter = 0;
  for (build in job.getBuilds()) {
    // It is possible for a build to have multiple BuildData actions
    // since we can use the Mulitple SCM plugin.
    def gitActions = build.getActions(hudson.plugins.git.util.BuildData.class)
    if (gitActions != null) {
      for (action in gitActions) {
        action.buildsByBranchName = new HashMap<String, Build>();
        hudson.plugins.git.Revision r = action.getLastBuiltRevision();
        if (r != null) {
          for (branch in r.getBranches()) {
            action.buildsByBranchName.put(branch.getName(), action.lastBuild)
          }
        }
        build.actions.remove(action)
        build.actions.add(action)
        build.save();
        counter++;
      }
    }
    if (job instanceof MatrixProject) {
      def runcounter = 0;
      for (run in build.getRuns()) {
        gitActions = run.getActions(hudson.plugins.git.util.BuildData.class)
        if (gitActions != null) {
          for (action in gitActions) {
            action.buildsByBranchName = new HashMap<String, Build>();
            hudson.plugins.git.Revision r = action.getLastBuiltRevision();
            if (r != null) {
              for (branch in r.getBranches()) {
                action.buildsByBranchName.put(branch.getName(), action.lastBuild)
              }
            }
            run.actions.remove(action)
            run.actions.add(action)
            run.save();
            runcounter++;
          }
        }
      }
      if (runcounter > 0) {
        println("" -->> cleaned: "" + runcounter + "" runs"");
      }
    }
  }
  if (counter > 0) {
    println(""-- cleaned: "" + counter + "" builds"");
  }
}
----
",12049,False,2005.666762413954,median
"/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkPolyData.cxx

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#include ""vtkPolyData.h""

#include ""vtkCellArray.h""
#include ""vtkCellData.h""
#include ""vtkCriticalSection.h""
#include ""vtkEmptyCell.h""
#include ""vtkGenericCell.h""
#include ""vtkInformation.h""
#include ""vtkInformationVector.h""
#include ""vtkLine.h""
#include ""vtkNew.h""
#include ""vtkObjectFactory.h""
#include ""vtkPointData.h""
#include ""vtkPointLocator.h""
#include ""vtkPolyLine.h""
#include ""vtkPolyVertex.h""
#include ""vtkPolygon.h""
#include ""vtkQuad.h""
#include ""vtkTriangle.h""
#include ""vtkTriangleStrip.h""
#include ""vtkVertex.h""

#include ""vtkSmartPointer.h""

vtkStandardNewMacro(vtkPolyData);

//----------------------------------------------------------------------------
// Initialize static member.  This member is used to simplify traversal
// of verts, lines, polygons, and triangle strips lists.  It basically
// ""marks"" empty lists so that the traveral method ""GetNextCell""
// works properly.

struct vtkPolyDataDummyContainter
{
  vtkSmartPointer<vtkCellArray> Dummy;

  vtkPolyDataDummyContainter()
    {
      this->Dummy.TakeReference(vtkCellArray::New());
    }
};

vtkPolyDataDummyContainter vtkPolyData::DummyContainer;

vtkPolyData::vtkPolyData () :
  Vertex(NULL), PolyVertex(NULL), Line(NULL), PolyLine(NULL),
  Triangle(NULL), Quad(NULL), Polygon(NULL), TriangleStrip(NULL),
  EmptyCell(NULL), Verts(NULL), Lines(NULL), Polys(NULL),
  Strips(NULL), Cells(NULL), Links(NULL)
{
  this->Information->Set(vtkDataObject::DATA_EXTENT_TYPE(), VTK_PIECES_EXTENT);
  this->Information->Set(vtkDataObject::DATA_PIECE_NUMBER(), -1);
  this->Information->Set(vtkDataObject::DATA_NUMBER_OF_PIECES(), 1);
  this->Information->Set(vtkDataObject::DATA_NUMBER_OF_GHOST_LEVELS(), 0);
}

//----------------------------------------------------------------------------
vtkPolyData::~vtkPolyData()
{
  this->Cleanup();

  if (this->Vertex)
    {
    this->Vertex->Delete();
    }

  if (this->PolyVertex)
    {
    this->PolyVertex->Delete();
    }

  if (this->Line)
    {
    this->Line->Delete();
    }

  if (this->PolyLine)
    {
    this->PolyLine->Delete();
    }

  if (this->Triangle)
    {
    this->Triangle->Delete();
    }

  if (this->Quad)
    {
    this->Quad->Delete();
    }

  if (this->Polygon)
    {
    this->Polygon->Delete();
    }

  if (this->TriangleStrip)
    {
    this->TriangleStrip->Delete();
    }

  if (this->EmptyCell)
    {
    this->EmptyCell->Delete();
    }
}

//----------------------------------------------------------------------------
int vtkPolyData::GetPiece()
{
  return this->Information->Get(vtkDataObject::DATA_PIECE_NUMBER());
}

//----------------------------------------------------------------------------
int vtkPolyData::GetNumberOfPieces()
{
  return this->Information->Get(vtkDataObject::DATA_NUMBER_OF_PIECES());
}

//----------------------------------------------------------------------------
int vtkPolyData::GetGhostLevel()
{
  return this->Information->Get(vtkDataObject::DATA_NUMBER_OF_GHOST_LEVELS());
}

//----------------------------------------------------------------------------
// Copy the geometric and topological structure of an input poly data object.
void vtkPolyData::CopyStructure(vtkDataSet *ds)
{
  vtkPolyData *pd=static_cast<vtkPolyData *>(ds);
  vtkPointSet::CopyStructure(ds);

  if (this->Verts != pd->Verts)
    {
    if (this->Verts)
      {
      this->Verts->UnRegister(this);
      }
    this->Verts = pd->Verts;
    if (this->Verts)
      {
      this->Verts->Register(this);
      }
    }

  if (this->Lines != pd->Lines)
    {
    if (this->Lines)
      {
      this->Lines->UnRegister(this);
      }
    this->Lines = pd->Lines;
    if (this->Lines)
      {
      this->Lines->Register(this);
      }
    }

  if (this->Polys != pd->Polys)
    {
    if (this->Polys)
      {
      this->Polys->UnRegister(this);
      }
    this->Polys = pd->Polys;
    if (this->Polys)
      {
      this->Polys->Register(this);
      }
    }

  if (this->Strips != pd->Strips)
    {
    if (this->Strips)
      {
      this->Strips->UnRegister(this);
      }
    this->Strips = pd->Strips;
    if (this->Strips)
      {
      this->Strips->Register(this);
      }
    }

  if ( this->Cells )
    {
    this->Cells->UnRegister(this);
    this->Cells = NULL;
    }

  if ( this->Links )
    {
    this->Links->UnRegister(this);
    this->Links = NULL;
    }
}

//----------------------------------------------------------------------------
int vtkPolyData::GetCellType(vtkIdType cellId)
{
  if ( !this->Cells )
    {
    this->BuildCells();
    }
  return this->Cells->GetCellType(cellId);
}

//----------------------------------------------------------------------------
vtkCell *vtkPolyData::GetCell(vtkIdType cellId)
{
  int i, loc;
  vtkIdType *pts, numPts;
  vtkCell *cell = NULL;
  unsigned char type;

  if ( !this->Cells )
    {
    this->BuildCells();
    }

  type = this->Cells->GetCellType(cellId);
  loc = this->Cells->GetCellLocation(cellId);

  switch (type)
    {
    case VTK_VERTEX:
      if (!this->Vertex)
        {
        this->Vertex = vtkVertex::New();
        }
      cell = this->Vertex;
      this->Verts->GetCell(loc,numPts,pts);
      break;

    case VTK_POLY_VERTEX:
      if (! this->PolyVertex)
        {
        this->PolyVertex = vtkPolyVertex::New();
        }
      cell = this->PolyVertex;
      this->Verts->GetCell(loc,numPts,pts);
      cell->PointIds->SetNumberOfIds(numPts); //reset number of points
      cell->Points->SetNumberOfPoints(numPts);
      break;

    case VTK_LINE:
      if (! this->Line )
        {
        this->Line = vtkLine::New();
        }
      cell = this->Line;
      this->Lines->GetCell(loc,numPts,pts);
      break;

    case VTK_POLY_LINE:
      if (!this->PolyLine)
        {
        this->PolyLine = vtkPolyLine::New();
        }
      cell = this->PolyLine;
      this->Lines->GetCell(loc,numPts,pts);
      cell->PointIds->SetNumberOfIds(numPts); //reset number of points
      cell->Points->SetNumberOfPoints(numPts);
      break;

    case VTK_TRIANGLE:
      if (!this->Triangle)
        {
        this->Triangle = vtkTriangle::New();
        }
      cell = this->Triangle;
      this->Polys->GetCell(loc,numPts,pts);
      break;

    case VTK_QUAD:
      if (!this->Quad)
        {
        this->Quad = vtkQuad::New();
        }
      cell = this->Quad;
      this->Polys->GetCell(loc,numPts,pts);
      break;

    case VTK_POLYGON:
      if (!this->Polygon)
        {
        this->Polygon = vtkPolygon::New();
        }
      cell = this->Polygon;
      this->Polys->GetCell(loc,numPts,pts);
      cell->PointIds->SetNumberOfIds(numPts); //reset number of points
      cell->Points->SetNumberOfPoints(numPts);
      break;

    case VTK_TRIANGLE_STRIP:
      if (!this->TriangleStrip)
        {
        this->TriangleStrip = vtkTriangleStrip::New();
        }
      cell = this->TriangleStrip;
      this->Strips->GetCell(loc,numPts,pts);
      cell->PointIds->SetNumberOfIds(numPts); //reset number of points
      cell->Points->SetNumberOfPoints(numPts);
      break;

    default:
      if (!this->EmptyCell)
        {
        this->EmptyCell = vtkEmptyCell::New();
        }
      cell = this->EmptyCell;
      return cell;
    }

  for (i=0; i < numPts; i++)
    {
    cell->PointIds->SetId(i,pts[i]);
    cell->Points->SetPoint(i,this->Points->GetPoint(pts[i]));
    }

  return cell;
}

//----------------------------------------------------------------------------
void vtkPolyData::GetCell(vtkIdType cellId, vtkGenericCell *cell)
{
  int             i, loc;
  vtkIdType       *pts=0;
  vtkIdType       numPts;
  unsigned char   type;
  double           x[3];

  if ( !this->Cells )
    {
    this->BuildCells();
    }

  type = this->Cells->GetCellType(cellId);
  loc = this->Cells->GetCellLocation(cellId);

  switch (type)
    {
    case VTK_VERTEX:
      cell->SetCellTypeToVertex();
      this->Verts->GetCell(loc,numPts,pts);
      break;

    case VTK_POLY_VERTEX:
      cell->SetCellTypeToPolyVertex();
      this->Verts->GetCell(loc,numPts,pts);
      cell->PointIds->SetNumberOfIds(numPts); //reset number of points
      cell->Points->SetNumberOfPoints(numPts);
      break;

    case VTK_LINE:
      cell->SetCellTypeToLine();
      this->Lines->GetCell(loc,numPts,pts);
      break;

    case VTK_POLY_LINE:
      cell->SetCellTypeToPolyLine();
      this->Lines->GetCell(loc,numPts,pts);
      cell->PointIds->SetNumberOfIds(numPts); //reset number of points
      cell->Points->SetNumberOfPoints(numPts);
      break;

    case VTK_TRIANGLE:
      cell->SetCellTypeToTriangle();
      this->Polys->GetCell(loc,numPts,pts);
      break;

    case VTK_QUAD:
      cell->SetCellTypeToQuad();
      this->Polys->GetCell(loc,numPts,pts);
      break;

    case VTK_POLYGON:
      cell->SetCellTypeToPolygon();
      this->Polys->GetCell(loc,numPts,pts);
      cell->PointIds->SetNumberOfIds(numPts); //reset number of points
      cell->Points->SetNumberOfPoints(numPts);
      break;

    case VTK_TRIANGLE_STRIP:
      cell->SetCellTypeToTriangleStrip();
      this->Strips->GetCell(loc,numPts,pts);
      cell->PointIds->SetNumberOfIds(numPts); //reset number of points
      cell->Points->SetNumberOfPoints(numPts);
      break;

    default:
      cell->SetCellTypeToEmptyCell();
      numPts = 0;
    }

  for (i=0; i < numPts; i++)
    {
    cell->PointIds->SetId(i,pts[i]);
    this->Points->GetPoint(pts[i], x);
    cell->Points->SetPoint(i, x);
    }
}

//----------------------------------------------------------------------------
void vtkPolyData::CopyCells(vtkPolyData *pd, vtkIdList *idList,
                            vtkPointLocator *locator)
{
  vtkIdType cellId, ptId, newId, newCellId, locatorPtId;
  int numPts, numCellPts, i;
  vtkPoints *newPoints;
  vtkIdList *pointMap = vtkIdList::New(); //maps old pt ids into new
  vtkIdList *cellPts, *newCellPts = vtkIdList::New();
  vtkGenericCell *cell = vtkGenericCell::New();
  double x[3];
  vtkPointData *outPD = this->GetPointData();
  vtkCellData *outCD = this->GetCellData();

  numPts = pd->GetNumberOfPoints();

  if (this->GetPoints() == NULL)
    {
    this->Points = vtkPoints::New();
    }

  newPoints = this->GetPoints();

  pointMap->SetNumberOfIds(numPts);
  for (i=0; i < numPts; i++)
    {
    pointMap->SetId(i,-1);
    }

  // Filter the cells
  for (cellId=0; cellId < idList->GetNumberOfIds(); cellId++)
    {
    pd->GetCell(idList->GetId(cellId), cell);
    cellPts = cell->GetPointIds();
    numCellPts = cell->GetNumberOfPoints();

    for (i=0; i < numCellPts; i++)
      {
      ptId = cellPts->GetId(i);
      if ( (newId = pointMap->GetId(ptId)) < 0 )
        {
        pd->GetPoint(ptId, x);
        if (locator != NULL)
          {
          if ((locatorPtId = locator->IsInsertedPoint(x)) == -1)
            {
            newId = newPoints->InsertNextPoint(x);
            locator->InsertNextPoint(x);
            pointMap->SetId(ptId, newId);
            outPD->CopyData(pd->GetPointData(), ptId, newId);
            }
          else
            {
            newId = locatorPtId;
            }
          }
        else
          {
          newId = newPoints->InsertNextPoint(x);
          pointMap->SetId(ptId, newId);
          outPD->CopyData(pd->GetPointData(), ptId, newId);
          }
        }
      newCellPts->InsertId(i,newId);
      }
    newCellId = this->InsertNextCell(cell->GetCellType(), newCellPts);
    outCD->CopyData(pd->GetCellData(), idList->GetId(cellId), newCellId);
    newCellPts->Reset();
    } // for all cells
  newCellPts->Delete();
  pointMap->Delete();
  cell->Delete();
}

//----------------------------------------------------------------------------
// Fast implementation of GetCellBounds().  Bounds are calculated without
// constructing a cell.
void vtkPolyData::GetCellBounds(vtkIdType cellId, double bounds[6])
{
  int i, loc;
  vtkIdType *pts, numPts;
  unsigned char type;
  double x[3];

  if ( !this->Cells )
    {
    this->BuildCells();
    }

  type = this->Cells->GetCellType(cellId);
  loc = this->Cells->GetCellLocation(cellId);

  switch (type)
    {
    case VTK_VERTEX:
    case VTK_POLY_VERTEX:
      this->Verts->GetCell(loc,numPts,pts);
      break;

    case VTK_LINE:
    case VTK_POLY_LINE:
      this->Lines->GetCell(loc,numPts,pts);
      break;

    case VTK_TRIANGLE:
    case VTK_QUAD:
    case VTK_POLYGON:
      this->Polys->GetCell(loc,numPts,pts);
      break;

    case VTK_TRIANGLE_STRIP:
      this->Strips->GetCell(loc,numPts,pts);
      break;

    default:
      bounds[0] = bounds[1] = bounds[2] = bounds[3] = bounds[4] = bounds[5]
        = 0.0;
      return;
    }

  // carefully compute the bounds
  if (numPts)
    {
    this->Points->GetPoint( pts[0], x );
    bounds[0] = x[0];
    bounds[2] = x[1];
    bounds[4] = x[2];
    bounds[1] = x[0];
    bounds[3] = x[1];
    bounds[5] = x[2];
    for (i=1; i < numPts; i++)
      {
      this->Points->GetPoint( pts[i], x );
      bounds[0] = (x[0] < bounds[0] ? x[0] : bounds[0]);
      bounds[1] = (x[0] > bounds[1] ? x[0] : bounds[1]);
      bounds[2] = (x[1] < bounds[2] ? x[1] : bounds[2]);
      bounds[3] = (x[1] > bounds[3] ? x[1] : bounds[3]);
      bounds[4] = (x[2] < bounds[4] ? x[2] : bounds[4]);
      bounds[5] = (x[2] > bounds[5] ? x[2] : bounds[5]);
      }
    }
  else
    {
    vtkMath::UninitializeBounds(bounds);
    }
}


//----------------------------------------------------------------------------
void vtkPolyData::ComputeBounds()
{
  if (this->GetMTime() > this->ComputeTime)
    {
    // If there are no cells, but there are points, back to the
    // bounds of the points set.
    if (this->GetNumberOfCells() == 0 && this->GetNumberOfPoints())
      {
      vtkPointSet::ComputeBounds();
      return;
      }

    int t, i;
    vtkIdType *pts = 0;
    vtkIdType npts = 0;
    double x[3];

    vtkCellArray *cella[4];

    cella[0] = this->GetVerts();
    cella[1] = this->GetLines();
    cella[2] = this->GetPolys();
    cella[3] = this->GetStrips();

    // carefully compute the bounds
    int doneOne = 0;
    this->Bounds[0] = this->Bounds[2] = this->Bounds[4] =  VTK_DOUBLE_MAX;
    this->Bounds[1] = this->Bounds[3] = this->Bounds[5] = -VTK_DOUBLE_MAX;

    // Iterate over cells's points
    for (t = 0; t < 4; t++)
      {
      for (cella[t]->InitTraversal(); cella[t]->GetNextCell(npts,pts); )
        {
        for (i = 0;  i < npts; i++)
          {
          this->Points->GetPoint( pts[i], x );
          this->Bounds[0] = (x[0] < this->Bounds[0] ? x[0] : this->Bounds[0]);
          this->Bounds[1] = (x[0] > this->Bounds[1] ? x[0] : this->Bounds[1]);
          this->Bounds[2] = (x[1] < this->Bounds[2] ? x[1] : this->Bounds[2]);
          this->Bounds[3] = (x[1] > this->Bounds[3] ? x[1] : this->Bounds[3]);
          this->Bounds[4] = (x[2] < this->Bounds[4] ? x[2] : this->Bounds[4]);
          this->Bounds[5] = (x[2] > this->Bounds[5] ? x[2] : this->Bounds[5]);
          doneOne = 1;
          }
        }
      }
    if (!doneOne)
      {
      vtkMath::UninitializeBounds(this->Bounds);
      }
    this->ComputeTime.Modified();
    }
}

//----------------------------------------------------------------------------
// Set the cell array defining vertices.
void vtkPolyData::SetVerts (vtkCellArray* v)
{
  if (v == this->DummyContainer.Dummy.GetPointer())
    {
    v = NULL;
    }
  if ( v != this->Verts)
    {
    if (this->Verts)
      {
      this->Verts->UnRegister(this);
      }
    this->Verts = v;
    if (this->Verts)
      {
      this->Verts->Register(this);
      }
    this->Modified();
    }
}

//----------------------------------------------------------------------------
// Get the cell array defining vertices. If there are no vertices, an
// empty array will be returned (convenience to simplify traversal).
vtkCellArray* vtkPolyData::GetVerts()
{
  if ( !this->Verts )
    {
    return this->DummyContainer.Dummy.GetPointer();
    }
  else
    {
    return this->Verts;
    }
}

//----------------------------------------------------------------------------
// Set the cell array defining lines.
void vtkPolyData::SetLines (vtkCellArray* l)
{
  if (l == this->DummyContainer.Dummy.GetPointer())
    {
    l = NULL;
    }
  if ( l != this->Lines)
    {
    if (this->Lines)
      {
      this->Lines->UnRegister(this);
      }
    this->Lines = l;
    if (this->Lines)
      {
      this->Lines->Register(this);
      }
    this->Modified();
    }
}

//----------------------------------------------------------------------------
// Get the cell array defining lines. If there are no lines, an
// empty array will be returned (convenience to simplify traversal).
vtkCellArray* vtkPolyData::GetLines()
{
  if ( !this->Lines )
    {
    return this->DummyContainer.Dummy.GetPointer();
    }
  else
    {
    return this->Lines;
    }
}

//----------------------------------------------------------------------------
// Set the cell array defining polygons.
void vtkPolyData::SetPolys (vtkCellArray* p)
{
  if(p == this->DummyContainer.Dummy.GetPointer())
    {
    p = NULL;
    }
  if ( p != this->Polys)
    {
    if (this->Polys)
      {
      this->Polys->UnRegister(this);
      }
    this->Polys = p;
    if (this->Polys)
      {
      this->Polys->Register(this);
      }
    this->Modified();
    }
}

//----------------------------------------------------------------------------
// Get the cell array defining polygons. If there are no polygons, an
// empty array will be returned (convenience to simplify traversal).
vtkCellArray* vtkPolyData::GetPolys()
{
  if ( !this->Polys )
    {
    return this->DummyContainer.Dummy.GetPointer();
    }
  else
    {
    return this->Polys;
    }
}

//----------------------------------------------------------------------------
// Set the cell array defining triangle strips.
void vtkPolyData::SetStrips (vtkCellArray* s)
{
  if ( s == this->DummyContainer.Dummy.GetPointer())
    {
    s = NULL;
    }
  if ( s != this->Strips)
    {
    if (this->Strips)
      {
      this->Strips->UnRegister(this);
      }
    this->Strips = s;
    if (this->Strips)
      {
      this->Strips->Register(this);
      }
    this->Modified();
    }
}

//----------------------------------------------------------------------------
// Get the cell array defining triangle strips. If there are no
// triangle strips, an empty array will be returned (convenience to
// simplify traversal).
vtkCellArray* vtkPolyData::GetStrips()
{
  if ( !this->Strips )
    {
    return this->DummyContainer.Dummy.GetPointer();
    }
  else
    {
    return this->Strips;
    }
}

//----------------------------------------------------------------------------
void vtkPolyData::Cleanup()
{
  if ( this->Verts )
    {
    this->Verts->UnRegister(this);
    this->Verts = NULL;
    }

  if ( this->Lines )
    {
    this->Lines->UnRegister(this);
    this->Lines = NULL;
    }

  if ( this->Polys )
    {
    this->Polys->UnRegister(this);
    this->Polys = NULL;
    }

  if ( this->Strips )
    {
    this->Strips->UnRegister(this);
    this->Strips = NULL;
    }

  if ( this->Cells )
    {
    this->Cells->UnRegister(this);
    this->Cells = NULL;
    }

  if ( this->Links )
    {
    this->Links->UnRegister(this);
    this->Links = NULL;
    }
}

//----------------------------------------------------------------------------
// Restore object to initial state. Release memory back to system.
void vtkPolyData::Initialize()
{
  vtkPointSet::Initialize();

  this->Cleanup();

  if(this->Information)
    {
    this->Information->Set(vtkDataObject::DATA_PIECE_NUMBER(), -1);
    this->Information->Set(vtkDataObject::DATA_NUMBER_OF_PIECES(), 0);
    this->Information->Set(vtkDataObject::DATA_NUMBER_OF_GHOST_LEVELS(), 0);
    }
}

//----------------------------------------------------------------------------
int vtkPolyData::GetMaxCellSize()
{
  int maxCellSize=0, cellSize;

  if ( this->Verts )
    {
    cellSize = this->Verts->GetMaxCellSize();
    if ( cellSize > maxCellSize )
      {
      maxCellSize = cellSize;
      }
    }

  if ( this->Lines )
    {
    cellSize = this->Lines->GetMaxCellSize();
    if ( cellSize > maxCellSize )
      {
      maxCellSize = cellSize;
      }
    }

  if ( this->Polys )
    {
    cellSize = this->Polys->GetMaxCellSize();
    if ( cellSize > maxCellSize )
      {
      maxCellSize = cellSize;
      }
    }

  if ( this->Strips )
    {
    cellSize = this->Strips->GetMaxCellSize();
    if ( cellSize > maxCellSize )
      {
      maxCellSize = cellSize;
      }
    }

  return maxCellSize;
}

//----------------------------------------------------------------------------
vtkIdType vtkPolyData::GetNumberOfCells()
{
  return this->GetNumberOfVerts() + this->GetNumberOfLines() +
         this->GetNumberOfPolys() + this->GetNumberOfStrips();
}

//----------------------------------------------------------------------------
vtkIdType vtkPolyData::GetNumberOfVerts()
{
  return (this->Verts ? this->Verts->GetNumberOfCells() : 0);
}

vtkIdType vtkPolyData::GetNumberOfLines()
{
  return (this->Lines ? this->Lines->GetNumberOfCells() : 0);
}

vtkIdType vtkPolyData::GetNumberOfPolys()
{
  return (this->Polys ? this->Polys->GetNumberOfCells() : 0);
}

vtkIdType vtkPolyData::GetNumberOfStrips()
{
  return (this->Strips ? this->Strips->GetNumberOfCells() : 0);
}


//----------------------------------------------------------------------------
void vtkPolyData::DeleteCells()
{
  // if we have Links, we need to delete them (they are no longer valid)
  if (this->Links)
    {
    this->Links->UnRegister( this );
    this->Links = NULL;
    }

  if (this->Cells)
    {
    this->Cells->UnRegister( this );
    this->Cells = NULL;
    }
}

//----------------------------------------------------------------------------
// Create data structure that allows random access of cells.
void vtkPolyData::BuildCells()
{
  if (this->Cells)
    {
    this->DeleteCells();
    }

  vtkCellArray *vertCells = this->GetVerts();
  vtkCellArray *lineCells = this->GetLines();
  vtkCellArray *polyCells = this->GetPolys();
  vtkCellArray *stripCells = this->GetStrips();

  // here are the number of cells we have
  vtkIdType nVerts = vertCells->GetNumberOfCells();
  vtkIdType nLines = lineCells->GetNumberOfCells();
  vtkIdType nPolys = polyCells->GetNumberOfCells();
  vtkIdType nStrips = stripCells->GetNumberOfCells();

  // pre-allocate the space we need
  vtkIdType nCells = nVerts + nLines + nPolys + nStrips;

  vtkUnsignedCharArray *types = vtkUnsignedCharArray::New();
  unsigned char *pTypes = types->WritePointer(0, nCells);

  vtkIntArray *locs = vtkIntArray::New();
  int *pLocs = locs->WritePointer(0, nCells);

  // record locations and type of each cell.
  // verts
  vtkIdType numCellPts;
  vtkIdType nextCellPts;
  if (nVerts)
    {
    vtkIdType *pVerts = vertCells->GetData()->GetPointer(0);
    numCellPts = pVerts[0];
    nextCellPts = numCellPts + 1;
    pLocs[0] = 0;
    pTypes[0] = numCellPts > 1 ? VTK_POLY_VERTEX : VTK_VERTEX;
    for (vtkIdType i = 1; i < nVerts; ++i)
      {
      numCellPts = pVerts[nextCellPts];
      pLocs[i] = nextCellPts;
      pTypes[i] = numCellPts > 1 ? VTK_POLY_VERTEX : VTK_VERTEX;
      nextCellPts += numCellPts + 1;
      }
    pLocs += nVerts;
    pTypes += nVerts;
    }

  // lines
  if (nLines)
    {
    vtkIdType *pLines = lineCells->GetData()->GetPointer(0);
    numCellPts = pLines[0];
    pLocs[0] = 0;
    pTypes[0] = numCellPts > 2 ? VTK_POLY_LINE : VTK_LINE;
    nextCellPts = numCellPts + 1;
    for (vtkIdType i = 1; i < nLines; ++i)
      {
      numCellPts = pLines[nextCellPts];
      pLocs[i] = nextCellPts;
      pTypes[i] = numCellPts > 2 ? VTK_POLY_LINE : VTK_LINE;
      nextCellPts += numCellPts + 1;
      }
    pLocs += nLines;
    pTypes += nLines;
    }

  // polys
  if (nPolys)
    {
    vtkIdType *pPolys = polyCells->GetData()->GetPointer(0);
    numCellPts = pPolys[0];
    pLocs[0] = 0;
    pTypes[0] = numCellPts == 3 ? VTK_TRIANGLE :
      numCellPts == 4 ? VTK_QUAD : VTK_POLYGON;
    nextCellPts = numCellPts + 1;
    for (vtkIdType i = 1; i < nPolys; ++i)
      {
      numCellPts = pPolys[nextCellPts];
      pLocs[i] = nextCellPts;
      pTypes[i] = numCellPts == 3 ? VTK_TRIANGLE :
        numCellPts == 4 ? VTK_QUAD : VTK_POLYGON;
      nextCellPts += numCellPts + 1;
      }
    pLocs += nPolys;
    pTypes += nPolys;
    }

  // strips
  if (nStrips)
    {
    std::fill_n(pTypes, nStrips, VTK_TRIANGLE_STRIP);
    vtkIdType *pStrips = stripCells->GetData()->GetPointer(0);
    numCellPts = pStrips[0];
    pLocs[0] = 0;
    nextCellPts = numCellPts + 1;
    for (vtkIdType i = 1; i < nStrips; ++i)
      {
      numCellPts = pStrips[nextCellPts];
      pLocs[i] = nextCellPts;
      nextCellPts += numCellPts + 1;
      }
    }

  // set up the cell types data structure
  this->Cells = vtkCellTypes::New();
  this->Cells->SetCellTypes(nCells, types, locs);
  this->Cells->Register(this);
  this->Cells->Delete();
  types->Delete();
  locs->Delete();
}

//----------------------------------------------------------------------------
void vtkPolyData::DeleteLinks()
{
  if (this->Links)
    {
    this->Links->UnRegister( this );
    this->Links = NULL;
    }
}

//----------------------------------------------------------------------------
// Create upward links from points to cells that use each point. Enables
// topologically complex queries.
void vtkPolyData::BuildLinks(int initialSize)
{
  if ( this->Links )
    {
    this->DeleteLinks();
    }

  if ( this->Cells == NULL )
    {
    this->BuildCells();
    }

  this->Links = vtkCellLinks::New();
  if ( initialSize > 0 )
    {
    this->Links->Allocate(initialSize);
    }
  else
    {
    this->Links->Allocate(this->GetNumberOfPoints());
    }
  this->Links->Register(this);
  this->Links->Delete();

  this->Links->BuildLinks(this);
}

//----------------------------------------------------------------------------
// Copy a cells point ids into list provided. (Less efficient.)
void vtkPolyData::GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)
{
  vtkIdType i;
  vtkIdType *pts, npts;

  ptIds->Reset();
  if ( this->Cells == NULL )
    {
    this->BuildCells();
    }

  this->vtkPolyData::GetCellPoints(cellId, npts, pts);
  ptIds->InsertId (npts-1,pts[npts-1]);
  for (i=0; i<npts-1; i++)
    {
    ptIds->SetId(i,pts[i]);
    }
}

//----------------------------------------------------------------------------
void vtkPolyData::GetPointCells(vtkIdType ptId, vtkIdList *cellIds)
{
  vtkIdType *cells;
  vtkIdType numCells;
  vtkIdType i;

  if ( ! this->Links )
    {
    this->BuildLinks();
    }
  cellIds->Reset();

  numCells = this->Links->GetNcells(ptId);
  cells = this->Links->GetCells(ptId);

  for (i=0; i < numCells; i++)
    {
    cellIds->InsertId(i,cells[i]);
    }
}

//----------------------------------------------------------------------------
// Method allocates initial storage for vertex, line, polygon, and
// triangle strip arrays. Use this method before the method
// PolyData::InsertNextCell(). (Or, provide vertex, line, polygon, and
// triangle strip cell arrays.)
void vtkPolyData::Allocate(vtkIdType numCells, int extSize)
{
  vtkCellArray *cells;

  if (!this->Cells)
    {
    this->Cells = vtkCellTypes::New();
    this->Cells->Allocate(numCells,3*numCells);
    // Consistent Register/UnRegister. (ShallowCopy).
    this->Cells->Register(this);
    this->Cells->Delete();
    }

  cells = vtkCellArray::New();
  cells->Allocate(numCells,extSize);
  this->SetVerts(cells);
  cells->Delete();

  cells = vtkCellArray::New();
  cells->Allocate(numCells,extSize);
  this->SetLines(cells);
  cells->Delete();

  cells = vtkCellArray::New();
  cells->Allocate(numCells,extSize);
  this->SetPolys(cells);
  cells->Delete();

  cells = vtkCellArray::New();
  cells->Allocate(numCells,extSize);
  this->SetStrips(cells);
  cells->Delete();
}

void vtkPolyData::Allocate(vtkPolyData *inPolyData, vtkIdType numCells,
                           int extSize)
{
  vtkCellArray *cells;
  int numVerts=inPolyData->GetVerts()->GetNumberOfCells();
  int numLines=inPolyData->GetLines()->GetNumberOfCells();
  int numPolys=inPolyData->GetPolys()->GetNumberOfCells();
  int numStrips=inPolyData->GetStrips()->GetNumberOfCells();
  int total=numVerts+numLines+numPolys+numStrips;

  if ( total <= 0 )
    {
    return;
    }

  if (!this->Cells)
    {
    this->Cells = vtkCellTypes::New();
    this->Cells->Allocate(numCells,3*numCells);
    // Consistent Register/UnRegister. (ShallowCopy).
    this->Cells->Register(this);
    this->Cells->Delete();
    }

  if ( numVerts > 0 )
    {
    cells = vtkCellArray::New();
    cells->Allocate(
      static_cast<int>(static_cast<double>(numVerts)/total*numCells),extSize);
    this->SetVerts(cells);
    cells->Delete();
    }
  if ( numLines > 0 )
    {
    cells = vtkCellArray::New();
    cells->Allocate(
      static_cast<int>(static_cast<double>(numLines)/total*numCells),extSize);
    this->SetLines(cells);
    cells->Delete();
    }
  if ( numPolys > 0 )
    {
    cells = vtkCellArray::New();
    cells->Allocate(
      static_cast<int>(static_cast<double>(numPolys)/total*numCells),extSize);
    this->SetPolys(cells);
    cells->Delete();
    }
  if ( numStrips > 0 )
    {
    cells = vtkCellArray::New();
    cells->Allocate(
      static_cast<int>(static_cast<double>(numStrips)/total*numCells),extSize);
    this->SetStrips(cells);
    cells->Delete();
    }
}

//----------------------------------------------------------------------------
// Insert a cell of type VTK_VERTEX, VTK_POLY_VERTEX, VTK_LINE, VTK_POLY_LINE,
// VTK_TRIANGLE, VTK_QUAD, VTK_POLYGON, or VTK_TRIANGLE_STRIP.  Make sure that
// the PolyData::Allocate() function has been called first or that vertex,
// line, polygon, and triangle strip arrays have been supplied.
// Note: will also insert VTK_PIXEL, but converts it to VTK_QUAD.
vtkIdType vtkPolyData::InsertNextCell(int type, int npts, vtkIdType *pts)
{
  int id;

  if ( !this->Cells )
    {
    // if we get to this point, the user has not made any guess at the
    // number of cells, so this guess is as good as any
    this->Cells = vtkCellTypes::New();
    this->Cells->Allocate(5000,10000);
    }

  switch (type)
    {
    case VTK_VERTEX: case VTK_POLY_VERTEX:
      this->Verts->InsertNextCell(npts,pts);
      id = this->Cells->InsertNextCell(type,
                                       this->Verts->GetInsertLocation(npts));
      break;

    case VTK_LINE: case VTK_POLY_LINE:
      this->Lines->InsertNextCell(npts,pts);
      id = this->Cells->InsertNextCell(type,
                                       this->Lines->GetInsertLocation(npts));
      break;

    case VTK_TRIANGLE: case VTK_QUAD: case VTK_POLYGON:
      this->Polys->InsertNextCell(npts,pts);
      id = this->Cells->InsertNextCell(type,
                                       this->Polys->GetInsertLocation(npts));
      break;

    case VTK_PIXEL: //need to rearrange vertices
      {
      vtkIdType pixPts[4];
      pixPts[0] = pts[0];
      pixPts[1] = pts[1];
      pixPts[2] = pts[3];
      pixPts[3] = pts[2];
      this->Polys->InsertNextCell(npts,pixPts);
      id = this->Cells->InsertNextCell(VTK_QUAD,
                                       this->Polys->GetInsertLocation(npts));
      break;
      }

    case VTK_TRIANGLE_STRIP:
      this->Strips->InsertNextCell(npts,pts);
      id = this->Cells->InsertNextCell(type,
                                       this->Strips->GetInsertLocation(npts));
      break;

    default:
      id = -1;
      vtkErrorMacro(<<""Bad cell type! Can't insert!"");
    }
  return id;
}

//----------------------------------------------------------------------------
// Insert a cell of type VTK_VERTEX, VTK_POLY_VERTEX, VTK_LINE, VTK_POLY_LINE,
// VTK_TRIANGLE, VTK_QUAD, VTK_POLYGON, or VTK_TRIANGLE_STRIP.  Make sure that
// the PolyData::Allocate() function has been called first or that vertex,
// line, polygon, and triangle strip arrays have been supplied.
// Note: will also insert VTK_PIXEL, but converts it to VTK_QUAD.
vtkIdType vtkPolyData::InsertNextCell(int type, vtkIdList *pts)
{
  vtkIdType id;
  vtkIdType npts = pts->GetNumberOfIds();

  if ( !this->Cells )
    {
    this->Cells = vtkCellTypes::New();
    this->Cells->Allocate(5000,10000);
    }

  switch (type)
    {
    case VTK_VERTEX: case VTK_POLY_VERTEX:
      this->Verts->InsertNextCell(pts);
      id = this->Cells->InsertNextCell(type, this->Verts->GetInsertLocation(npts));
      break;

    case VTK_LINE: case VTK_POLY_LINE:
      this->Lines->InsertNextCell(pts);
      id = this->Cells->InsertNextCell(type, this->Lines->GetInsertLocation(npts));
      break;

    case VTK_TRIANGLE: case VTK_QUAD: case VTK_POLYGON:
      this->Polys->InsertNextCell(pts);
      id = this->Cells->InsertNextCell(type, this->Polys->GetInsertLocation(npts));
      break;

    case VTK_PIXEL: //need to rearrange vertices
      {
      vtkIdType pixPts[4];
      pixPts[0] = pts->GetId(0);
      pixPts[1] = pts->GetId(1);
      pixPts[2] = pts->GetId(3);
      pixPts[3] = pts->GetId(2);
      this->Polys->InsertNextCell(4,pixPts);
      id = this->Cells->InsertNextCell(VTK_QUAD, this->Polys->GetInsertLocation(npts));
      break;
      }

    case VTK_TRIANGLE_STRIP:
      this->Strips->InsertNextCell(pts);
      id = this->Cells->InsertNextCell(type, this->Strips->GetInsertLocation(npts));
      break;

    case VTK_EMPTY_CELL:
      id = -1;
      // do nothing
      break;

    default:
      id = -1;
      vtkErrorMacro(<<""Bad cell type! Can't insert!"");
    }

  return id;
}

//----------------------------------------------------------------------------
// Recover extra allocated memory when creating data whose initial size
// is unknown. Examples include using the InsertNextCell() method, or
// when using the CellArray::EstimateSize() method to create vertices,
// lines, polygons, or triangle strips.
void vtkPolyData::Squeeze()
{
  if ( this->Verts != NULL )
    {
    this->Verts->Squeeze();
    }
  if ( this->Lines != NULL )
    {
    this->Lines->Squeeze();
    }
  if ( this->Polys != NULL )
    {
    this->Polys->Squeeze();
    }
  if ( this->Strips != NULL )
    {
    this->Strips->Squeeze();
    }

  vtkPointSet::Squeeze();
}

//----------------------------------------------------------------------------
// Begin inserting data all over again. Memory is not freed but otherwise
// objects are returned to their initial state.
void vtkPolyData::Reset()
{
  if ( this->Verts != NULL )
    {
    this->Verts->Reset();
    }
  if ( this->Lines != NULL )
    {
    this->Lines->Reset();
    }
  if ( this->Polys != NULL )
    {
    this->Polys->Reset();
    }
  if ( this->Strips != NULL )
    {
    this->Strips->Reset();
    }
}

//----------------------------------------------------------------------------
// Reverse the order of point ids defining the cell.
void vtkPolyData::ReverseCell(vtkIdType cellId)
{
  int loc, type;

  if ( this->Cells == NULL )
    {
    this->BuildCells();
    }
  loc = this->Cells->GetCellLocation(cellId);
  type = this->Cells->GetCellType(cellId);

  switch (type)
    {
    case VTK_VERTEX: case VTK_POLY_VERTEX:
     this->Verts->ReverseCell(loc);
     break;

    case VTK_LINE: case VTK_POLY_LINE:
      this->Lines->ReverseCell(loc);
      break;

    case VTK_TRIANGLE: case VTK_QUAD: case VTK_POLYGON:
      this->Polys->ReverseCell(loc);
      break;

    case VTK_TRIANGLE_STRIP:
      this->Strips->ReverseCell(loc);
      break;

    default:
      break;
    }
}

//----------------------------------------------------------------------------
// Add a point to the cell data structure (after cell pointers have been
// built). This method allocates memory for the links to the cells.  (To
// use this method, make sure points are available and BuildLinks() has been invoked.)
vtkIdType vtkPolyData::InsertNextLinkedPoint(int numLinks)
{
  return this->Links->InsertNextPoint(numLinks);
}

//----------------------------------------------------------------------------
// Add a point to the cell data structure (after cell pointers have been
// built). This method adds the point and then allocates memory for the
// links to the cells.  (To use this method, make sure points are available
// and BuildLinks() has been invoked.)
vtkIdType vtkPolyData::InsertNextLinkedPoint(double x[3], int numLinks)
{
  this->Links->InsertNextPoint(numLinks);
  return this->Points->InsertNextPoint(x);
}

//----------------------------------------------------------------------------
// Add a new cell to the cell data structure (after cell pointers have been
// built). This method adds the cell and then updates the links from the points
// to the cells. (Memory is allocated as necessary.)
vtkIdType vtkPolyData::InsertNextLinkedCell(int type, int npts, vtkIdType *pts)
{
  vtkIdType i, id;

  id = this->InsertNextCell(type,npts,pts);

  for (i=0; i<npts; i++)
    {
    this->Links->ResizeCellList(pts[i],1);
    this->Links->AddCellReference(id,pts[i]);
    }

  return id;
}

//----------------------------------------------------------------------------
// Remove a reference to a cell in a particular point's link list. You may also
// consider using RemoveCellReference() to remove the references from all the
// cell's points to the cell. This operator does not reallocate memory; use the
// operator ResizeCellList() to do this if necessary.
void vtkPolyData::RemoveReferenceToCell(vtkIdType ptId, vtkIdType cellId)
{
  this->Links->RemoveCellReference(cellId, ptId);
}

//----------------------------------------------------------------------------
// Add a reference to a cell in a particular point's link list. (You may also
// consider using AddCellReference() to add the references from all the
// cell's points to the cell.) This operator does not realloc memory; use the
// operator ResizeCellList() to do this if necessary.
void vtkPolyData::AddReferenceToCell(vtkIdType ptId, vtkIdType cellId)
{
  this->Links->AddCellReference(cellId, ptId);
}

//----------------------------------------------------------------------------
// Replace the points defining cell ""cellId"" with a new set of points. This
// operator is (typically) used when links from points to cells have not been
// built (i.e., BuildLinks() has not been executed). Use the operator
// ReplaceLinkedCell() to replace a cell when cell structure has been built.
void vtkPolyData::ReplaceCell(vtkIdType cellId, int npts, vtkIdType *pts)
{
  int loc, type;

  if ( this->Cells == NULL )
    {
    this->BuildCells();
    }
  loc = this->Cells->GetCellLocation(cellId);
  type = this->Cells->GetCellType(cellId);

  switch (type)
    {
    case VTK_VERTEX: case VTK_POLY_VERTEX:
     this->Verts->ReplaceCell(loc,npts,pts);
     break;

    case VTK_LINE: case VTK_POLY_LINE:
      this->Lines->ReplaceCell(loc,npts,pts);
      break;

    case VTK_TRIANGLE: case VTK_QUAD: case VTK_POLYGON:
      this->Polys->ReplaceCell(loc,npts,pts);
      break;

    case VTK_TRIANGLE_STRIP:
      this->Strips->ReplaceCell(loc,npts,pts);
      break;

    default:
      break;
    }
}

//----------------------------------------------------------------------------
// Replace one cell with another in cell structure. This operator updates the
// connectivity list and the point's link list. It does not delete references
// to the old cell in the point's link list. Use the operator
// RemoveCellReference() to delete all references from points to (old) cell.
// You may also want to consider using the operator ResizeCellList() if the
// link list is changing size.
void vtkPolyData::ReplaceLinkedCell(vtkIdType cellId, int npts, vtkIdType *pts)
{
  int loc = this->Cells->GetCellLocation(cellId);
  int type = this->Cells->GetCellType(cellId);

  switch (type)
    {
    case VTK_VERTEX: case VTK_POLY_VERTEX:
     this->Verts->ReplaceCell(loc,npts,pts);
     break;

    case VTK_LINE: case VTK_POLY_LINE:
      this->Lines->ReplaceCell(loc,npts,pts);
      break;

    case VTK_TRIANGLE: case VTK_QUAD: case VTK_POLYGON:
      this->Polys->ReplaceCell(loc,npts,pts);
      break;

    case VTK_TRIANGLE_STRIP:
      this->Strips->ReplaceCell(loc,npts,pts);
      break;

    default:
      npts = 0;
    }

  for (int i=0; i < npts; i++)
    {
    this->Links->InsertNextCellReference(pts[i],cellId);
    }
}

//----------------------------------------------------------------------------
// Get the neighbors at an edge. More efficient than the general
// GetCellNeighbors(). Assumes links have been built (with BuildLinks()),
// and looks specifically for edge neighbors.
void vtkPolyData::GetCellEdgeNeighbors(vtkIdType cellId, vtkIdType p1,
                                       vtkIdType p2, vtkIdList *cellIds)
{
  cellIds->Reset();

  const vtkCellLinks::Link &link1(this->Links->GetLink(p1));
  const vtkCellLinks::Link &link2(this->Links->GetLink(p2));

  const vtkIdType *cells1 = link1.cells;
  const vtkIdType *cells1End = cells1 + link1.ncells;

  const vtkIdType *cells2 = link2.cells;
  const vtkIdType *cells2End = cells2 + link2.ncells;

  while (cells1 != cells1End)
    {
    if (*cells1 != cellId)
      {
      const vtkIdType *cells2Cur(cells2);
      while (cells2Cur != cells2End)
        {
        if (*cells1 == *cells2Cur)
          {
          cellIds->InsertNextId(*cells1);
          break;
          }
        ++cells2Cur;
        }
      }
    ++cells1;
    }
}

//----------------------------------------------------------------------------
void vtkPolyData::GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
                                   vtkIdList *cellIds)
{
  vtkIdType i, j, numPts, cellNum;
  int allFound, oneFound;

  if ( ! this->Links )
    {
    this->BuildLinks();
    }

  cellIds->Reset();

  // load list with candidate cells, remove current cell
  vtkIdType ptId = ptIds->GetId(0);
  int numPrime = this->Links->GetNcells(ptId);
  vtkIdType *primeCells = this->Links->GetCells(ptId);
  numPts = ptIds->GetNumberOfIds();

  // for each potential cell
  for (cellNum = 0; cellNum < numPrime; cellNum++)
    {
    // ignore the original cell
    if (primeCells[cellNum] != cellId)
      {
      // are all the remaining points in the cell ?
      for (allFound=1, i=1; i < numPts && allFound; i++)
        {
        ptId = ptIds->GetId(i);
        int numCurrent = this->Links->GetNcells(ptId);
        vtkIdType *currentCells = this->Links->GetCells(ptId);
        oneFound = 0;
        for (j = 0; j < numCurrent; j++)
          {
          if (primeCells[cellNum] == currentCells[j])
            {
            oneFound = 1;
            break;
            }
          }
        if (!oneFound)
          {
          allFound = 0;
          }
        }
      if (allFound)
        {
        cellIds->InsertNextId(primeCells[cellNum]);
        }
      }
    }
}

int vtkPolyData::IsEdge(vtkIdType p1, vtkIdType p2)
{
  unsigned short int ncells;
  vtkIdType cellType;
  vtkIdType npts;
  vtkIdType i, j;
  vtkIdType *cells, *pts;

  vtkIdType nbPoints = this->GetNumberOfPoints();
  if (p1 >= nbPoints || p2 >= nbPoints)
    {
    return 0;
    }

  this->GetPointCells(p1,ncells,cells);
  for (i=0; i<ncells; i++)
    {
    cellType = this->GetCellType(cells[i]);
    switch (cellType)
      {
      case VTK_EMPTY_CELL: case VTK_VERTEX: case VTK_POLY_VERTEX: case VTK_LINE: case VTK_POLY_LINE:
        break;
      case VTK_TRIANGLE:
        if ( this->IsPointUsedByCell(p2,cells[i]) )
          {
          return 1;
          }
        break;
      case VTK_QUAD:
        this->GetCellPoints(cells[i],npts,pts);
        for (j=0; j<npts-1; j++)
          {
          if (((pts[j]==p1)&&(pts[j+1]==p2))||((pts[j]==p2)&&(pts[j+1]==p1)))
            {
            return 1;
            }
          }
        if (((pts[0]==p1)&&(pts[npts-1]==p2))||((pts[0]==p2)&&(pts[npts-1]==p1)))
          {
          return 1;
          }
        break;
      case VTK_TRIANGLE_STRIP:
        this->GetCellPoints(cells[i],npts,pts);
        for (j=0; j<npts-2; j++)
          {
          if ((((pts[j]==p1)&&(pts[j+1]==p2))||((pts[j]==p2)&&(pts[j+1]==p1)))||
              (((pts[j]==p1)&&(pts[j+2]==p2))||((pts[j]==p2)&&(pts[j+2]==p1))))
            {
            return 1;
            }
          }
        if (((pts[npts-2]==p1)&&(pts[npts-1]==p2))||((pts[npts-2]==p2)&&(pts[npts-1]==p1)))
          {
          return 1;
          }
        break;
      default:
        this->GetCellPoints(cells[i],npts,pts);
        for (j=0; j<npts; j++)
          {
          if (p1==pts[j])
            {
            if ((pts[(j-1+npts)%npts]==p2)||(pts[(j+1)%npts]==p2))
              {
              return 1;
              }
            }
          }
      }
    }
  return 0;
}

//----------------------------------------------------------------------------

unsigned long vtkPolyData::GetActualMemorySize()
{
  unsigned long size=this->vtkPointSet::GetActualMemorySize();
  if ( this->Verts )
    {
    size += this->Verts->GetActualMemorySize();
    }
  if ( this->Lines )
    {
    size += this->Lines->GetActualMemorySize();
    }
  if ( this->Polys )
    {
    size += this->Polys->GetActualMemorySize();
    }
  if ( this->Strips )
    {
    size += this->Strips->GetActualMemorySize();
    }
  if ( this->Cells )
    {
    size += this->Cells->GetActualMemorySize();
    }
  if ( this->Links )
    {
    size += this->Links->GetActualMemorySize();
    }
  return size;
}

//----------------------------------------------------------------------------
void vtkPolyData::ShallowCopy(vtkDataObject *dataObject)
{
  vtkPolyData *polyData = vtkPolyData::SafeDownCast(dataObject);
  if (this == polyData)
     return;

  if ( polyData != NULL )
    {
    this->SetVerts(polyData->GetVerts());
    this->SetLines(polyData->GetLines());
    this->SetPolys(polyData->GetPolys());
    this->SetStrips(polyData->GetStrips());

    // I do not know if this is correct but.
    if (this->Cells)
      {
      this->Cells->UnRegister(this);
      }
    this->Cells = polyData->Cells;
    if (this->Cells)
      {
      this->Cells->Register(this);
      }

    if (this->Links)
      {
      this->Links->Delete();
      }
    this->Links = polyData->Links;
    if (this->Links)
      {
      this->Links->Register(this);
      }
    }

  // Do superclass
  this->vtkPointSet::ShallowCopy(dataObject);
}

//----------------------------------------------------------------------------
void vtkPolyData::DeepCopy(vtkDataObject *dataObject)
{
  // Do superclass
  // We have to do this BEFORE we call BuildLinks, else there are no points
  // to build the links on (the parent DeepCopy copies the points)
  this->vtkPointSet::DeepCopy(dataObject);

  vtkPolyData *polyData = vtkPolyData::SafeDownCast(dataObject);

  if ( polyData != NULL )
    {
    vtkCellArray *ca;
    ca = vtkCellArray::New();
    ca->DeepCopy(polyData->GetVerts());
    this->SetVerts(ca);
    ca->Delete();

    ca = vtkCellArray::New();
    ca->DeepCopy(polyData->GetLines());
    this->SetLines(ca);
    ca->Delete();

    ca = vtkCellArray::New();
    ca->DeepCopy(polyData->GetPolys());
    this->SetPolys(ca);
    ca->Delete();

    ca = vtkCellArray::New();
    ca->DeepCopy(polyData->GetStrips());
    this->SetStrips(ca);
    ca->Delete();

    if ( this->Cells )
      {
      this->Cells->UnRegister(this);
      this->Cells = NULL;
      }
    if (polyData->Cells)
      {
      this->BuildCells();
      }

    if ( this->Links )
      {
      this->Links->UnRegister(this);
      this->Links = NULL;
      }
    if (polyData->Links)
      {
      this->BuildLinks();
      }
    }
}

void vtkPolyData::RemoveGhostCells()
{
  // Get a pointer to the cell ghost level array.
  vtkUnsignedCharArray* temp = this->GetCellGhostArray();
  if (temp == NULL)
    {
    vtkDebugMacro(""Could not find cell ghost array."");
    return;
    }
  if (temp->GetNumberOfComponents() != 1 ||
      temp->GetNumberOfTuples() < this->GetNumberOfCells())
    {
    vtkErrorMacro(""Poorly formed ghost array."");
    return;
    }
  unsigned char* cellGhosts = temp->GetPointer(0);

  vtkIdType numCells = this->GetNumberOfCells();

  vtkIntArray *types = vtkIntArray::New();
  types->SetNumberOfValues(numCells);

  for (vtkIdType i = 0; i < numCells; i++)
    {
    types->SetValue(i, this->GetCellType(i));
    }

  this->DeleteCells();

  // we have to make new copies of Verts, Lines, Polys
  // and Strips since they may be shared with other polydata
  vtkSmartPointer<vtkCellArray> verts;
  if(this->Verts)
    {
    verts = this->Verts;
    verts->InitTraversal();
    this->Verts->UnRegister(this);
    this->Verts = vtkCellArray::New();
    }

  vtkSmartPointer<vtkCellArray> lines;
  if(this->Lines)
    {
    lines = this->Lines;
    lines->InitTraversal();
    this->Lines->UnRegister(this);
    this->Lines = vtkCellArray::New();
    }

  vtkSmartPointer<vtkCellArray> polys;
  if(this->Polys)
    {
    polys = this->Polys;
    polys->InitTraversal();
    this->Polys->UnRegister(this);
    this->Polys = vtkCellArray::New();
    }

  vtkSmartPointer<vtkCellArray> strips;
  if(this->Strips)
    {
    strips = this->Strips;
    strips->InitTraversal();
    this->Strips->UnRegister(this);
    this->Strips = vtkCellArray::New();
    }

  vtkCellData *newCellData = vtkCellData::New();
  newCellData->CopyAllocate(this->CellData, numCells);

  vtkIdType *pts, n;

  int cellId;

  for (vtkIdType i = 0; i < numCells; i++)
    {
    int type = types->GetValue(i);

    if (type == VTK_VERTEX || type == VTK_POLY_VERTEX)
      {
      verts->GetNextCell(n, pts);

      if (! (cellGhosts[i] & vtkDataSetAttributes::DUPLICATECELL))
        {
        cellId = this->InsertNextCell(type, n, pts);
        newCellData->CopyData(this->CellData, i, cellId);
        }
      }
    else if (type == VTK_LINE || type == VTK_POLY_LINE)
      {
      lines->GetNextCell(n, pts);

      if (! (cellGhosts[i] & vtkDataSetAttributes::DUPLICATECELL))
        {
        cellId = this->InsertNextCell(type, n, pts);
        newCellData->CopyData(this->CellData, i, cellId);
        }
      }
    else if (type == VTK_POLYGON || type == VTK_TRIANGLE || type == VTK_QUAD)
      {
      polys->GetNextCell(n, pts);

      if (! (cellGhosts[i] & vtkDataSetAttributes::DUPLICATECELL))
        {
        cellId = this->InsertNextCell(type, n, pts);
        newCellData->CopyData(this->CellData, i, cellId);
        }
      }
    else if (type == VTK_TRIANGLE_STRIP)
      {
      strips->GetNextCell(n, pts);

      if (! (cellGhosts[i] & vtkDataSetAttributes::DUPLICATECELL))
        {
        cellId = this->InsertNextCell(type, n, pts);
        newCellData->CopyData(this->CellData, i, cellId);
        }
      }
    }

  newCellData->Squeeze();

  this->CellData->ShallowCopy(newCellData);
  newCellData->Delete();

  types->Delete();

  // If there are no more ghost levels, then remove all arrays.
  this->CellData->RemoveArray(vtkDataSetAttributes::GhostArrayName());

  this->Squeeze();
}
//----------------------------------------------------------------------------
void vtkPolyData::RemoveDeletedCells()
{
  if (!this->Cells)
    {
      return;
    }

  vtkNew<vtkPolyData> oldData;
  oldData->ShallowCopy(this);
  this->DeleteCells();

  if(this->Verts)
    {
    this->Verts->UnRegister(this);
    this->Verts = vtkCellArray::New();
    }
  if(this->Lines)
    {
    this->Lines->UnRegister(this);
    this->Lines = vtkCellArray::New();
    }
  if(this->Polys)
    {
    this->Polys->UnRegister(this);
    this->Polys = vtkCellArray::New();
    }
  if(this->Strips)
    {
    this->Strips->UnRegister(this);
    this->Strips = vtkCellArray::New();
    }

  this->CellData->CopyAllocate(oldData->GetCellData());

  const vtkIdType numCells = oldData->GetNumberOfCells();
  vtkCell *cell;
  vtkIdType cellId;
  vtkIdList *pointIds;
  int type;
  for (vtkIdType i = 0; i < numCells; i++)
    {
    type = oldData->GetCellType(i);

    if (type != VTK_EMPTY_CELL)
      {
      cell = oldData->GetCell(i);
      pointIds = cell->GetPointIds();
      cellId = this->InsertNextCell(type, pointIds);
      this->CellData->CopyData(oldData->GetCellData(), i, cellId);
      }
    }

  this->CellData->Squeeze();
}
//----------------------------------------------------------------------------
vtkPolyData* vtkPolyData::GetData(vtkInformation* info)
{
  return info? vtkPolyData::SafeDownCast(info->Get(DATA_OBJECT())) : 0;
}

//----------------------------------------------------------------------------
vtkPolyData* vtkPolyData::GetData(vtkInformationVector* v, int i)
{
  return vtkPolyData::GetData(v->GetInformationObject(i));
}

//----------------------------------------------------------------------------
void vtkPolyData::PrintSelf(ostream& os, vtkIndent indent)
{
  this->Superclass::PrintSelf(os,indent);

  os << indent << ""Number Of Vertices: "" << this->GetNumberOfVerts() << ""\\n"";
  os << indent << ""Number Of Lines: "" << this->GetNumberOfLines() << ""\\n"";
  os << indent << ""Number Of Polygons: "" << this->GetNumberOfPolys() << ""\\n"";
  os << indent << ""Number Of Triangle Strips: "" << this->GetNumberOfStrips() << ""\\n"";

  os << indent << ""Number Of Pieces: "" << this->GetNumberOfPieces() << endl;
  os << indent << ""Piece: "" << this->GetPiece() << endl;
  os << indent << ""Ghost Level: "" << this->GetGhostLevel() << endl;
}


//----------------------------------------------------------------------------
int vtkPolyData::GetScalarFieldCriticalIndex (vtkIdType pointId,
                                              vtkDataArray *scalarField)
{
  /*
   * implements scalar field critical point classification for manifold
   * 2D meshes.
   */

  /*
   * returned value:
   *   -4: no such field
   *   -3: attribute check failed
   *   -2: non 2-manifold star
   *   -1: regular point
   *   0: minimum
   *   1: saddle
   *   2: maximum
   */

  bool  is_min = true, is_max = true;
  vtkIdList *starTriangleList = vtkIdList::New(),
            *lowerLinkPointList = vtkIdList::New(),
            *upperLinkPointList = vtkIdList::New(),
            *pointList = NULL;
  double pointFieldValue = scalarField->GetComponent(pointId, 0),
         neighborFieldValue = 0;

  if(this->GetNumberOfPoints() != scalarField->GetSize())
    return vtkPolyData::ERR_INCORRECT_FIELD;

  /* make sure the connectivity is built */
  if(!this->Links) this->BuildLinks();

  /* build the lower and upper links */
  this->GetPointCells(pointId, starTriangleList);
  int starNb = starTriangleList->GetNumberOfIds();
  for(int i = 0; i < starNb; i++)
    {
    vtkCell *c = this->GetCell(starTriangleList->GetId(i));
    pointList = c->GetPointIds();
    int pointNb = pointList->GetNumberOfIds();
    if(pointNb != 3)
      {
      starTriangleList->Delete();
      lowerLinkPointList->Delete();
      upperLinkPointList->Delete();
      return vtkPolyData::ERR_NON_MANIFOLD_STAR;
      }

    for(int j = 0; j < pointNb; j++)
      {
      vtkIdType  currentPointId = pointList->GetId(j);

      /* quick check for extrema */
      neighborFieldValue = scalarField->GetComponent(currentPointId, 0);
      if((currentPointId != pointId)&&(neighborFieldValue == pointFieldValue))
        {
        /* simulation of simplicity (Edelsbrunner et al. ACM ToG 1990) */
        if(currentPointId > pointId)
          {
          is_max = false;
          upperLinkPointList->InsertUniqueId(currentPointId);
          }
        if(currentPointId < pointId)
          {
          is_min = false;
          lowerLinkPointList->InsertUniqueId(currentPointId);
          }
        }
      else
        {
        if(neighborFieldValue > pointFieldValue)
          {
          is_max = false;
          upperLinkPointList->InsertUniqueId(currentPointId);
          }
        if(neighborFieldValue < pointFieldValue)
          {
          is_min = false;
          lowerLinkPointList->InsertUniqueId(currentPointId);
          }
        }
      }
    }

  if((is_max)||(is_min))
    {
    starTriangleList->Delete();
    lowerLinkPointList->Delete();
    upperLinkPointList->Delete();
    if(is_max) return vtkPolyData::MAXIMUM;
    if(is_min) return vtkPolyData::MINIMUM;
    }

  /*
   * is the vertex really regular?
   * (lower and upper links are BOTH simply connected)
   */
  int visitedPointNb = 0, stackBottom = 0,
      lowerLinkPointNb = lowerLinkPointList->GetNumberOfIds(),
      upperLinkPointNb = upperLinkPointList->GetNumberOfIds();

  /* first, check lower link's simply connectedness */
  vtkIdList *stack = vtkIdList::New();
  stack->InsertUniqueId(lowerLinkPointList->GetId(0));
  vtkIdType currentPointId = stack->GetId(stackBottom), nextPointId = -1;
  do
    {
    stackBottom++;
    vtkIdList *triangleList = vtkIdList::New();
    this->GetPointCells(currentPointId, triangleList);
    int triangleNb = triangleList->GetNumberOfIds();

    for(int i = 0; i < triangleNb; i++)
      {
      vtkCell *c = this->GetCell(triangleList->GetId(i));
      pointList = c->GetPointIds();;
      int pointNb = pointList->GetNumberOfIds();

      if(pointList->IsId(pointId) >= 0)
        {
        // those two triangles are in the star of pointId
        int j = 0;
        do
          {
          nextPointId = pointList->GetId(j);
          j++;
          }while(((nextPointId == pointId)
          ||(nextPointId == currentPointId))&&(j < pointNb ));
        }

      if(lowerLinkPointList->IsId(nextPointId) >= 0)
        {
        stack->InsertUniqueId(nextPointId);
        }

      }

    triangleList->Delete();
    visitedPointNb++;

    currentPointId = stack->GetId(stackBottom), nextPointId = -1;

  }while(stackBottom < stack->GetNumberOfIds());

  if(visitedPointNb != lowerLinkPointNb)
    {
    // the lower link is not simply connected, then it's a saddle
    stack->Delete();
    starTriangleList->Delete();
    lowerLinkPointList->Delete();
    upperLinkPointList->Delete();
    return vtkPolyData::SADDLE;
    }

  /*
   * then, check upper link's simply connectedness.
   * BOTH need to be checked if the 2-manifold has boundary components.
   */
  stackBottom = 0;
  visitedPointNb = 0;
  stack->Delete();
  stack = vtkIdList::New();
  stack->InsertUniqueId(upperLinkPointList->GetId(0));
  currentPointId = stack->GetId(stackBottom), nextPointId = -1;
  do
    {
    stackBottom++;
    vtkIdList *triangleList = vtkIdList::New();
    this->GetPointCells(currentPointId, triangleList);
    int triangleNb = triangleList->GetNumberOfIds();

    for(int i = 0; i < triangleNb; i++)
      {
      vtkCell *c = this->GetCell(triangleList->GetId(i));
      pointList = c->GetPointIds();
      int pointNb = pointList->GetNumberOfIds();

      if(pointList->IsId(pointId) >= 0)
        {
        // those two triangles are in the star of pointId
        int j = 0;
        do
          {
          nextPointId = pointList->GetId(j);
          j++;
          }while(((nextPointId == pointId)
          ||(nextPointId == currentPointId))&&(j < pointNb));
        }

      if(upperLinkPointList->IsId(nextPointId) >= 0)
        {
        stack->InsertUniqueId(nextPointId);
        }
      }

    triangleList->Delete();
    visitedPointNb++;

    currentPointId = stack->GetId(stackBottom), nextPointId = -1;
    }while(stackBottom < stack->GetNumberOfIds());

  if(visitedPointNb != upperLinkPointNb)
    {
    // the upper link is not simply connected, then it's a saddle
    stack->Delete();
    starTriangleList->Delete();
    lowerLinkPointList->Delete();
    upperLinkPointList->Delete();
    return vtkPolyData::SADDLE;
    }

  /* else it's necessarily a regular point (only 4 cases in 2D)*/
  stack->Delete();
  starTriangleList->Delete();
  lowerLinkPointList->Delete();
  upperLinkPointList->Delete();
  return vtkPolyData::REGULAR_POINT;
}

//----------------------------------------------------------------------------
int vtkPolyData::GetScalarFieldCriticalIndex (vtkIdType pointId,
                                              const char* fieldName)
{
  /*
   * returned value:
   *   -4: no such field
   *   -3: attribute check failed
   *   -2: non 2-manifold star
   *   -1: regular point
   *   0: minimum
   *   1: saddle
   *   2: maximum
   */

  int fieldId = 0;

  vtkPointData *pointData = this->GetPointData();
  vtkDataArray *scalarField = pointData->GetArray(fieldName, fieldId);

  if(!scalarField) return vtkPolyData::ERR_NO_SUCH_FIELD;

  return this->GetScalarFieldCriticalIndex(pointId, scalarField);

}

//----------------------------------------------------------------------------
int vtkPolyData::GetScalarFieldCriticalIndex (vtkIdType pointId, int fieldId)
{
  /*
   * returned value:
   *   -4: no such field
   *   -3: attribute check failed
   *   -2: non 2-manifold star
   *   -1: regular point
   *   0: minimum
   *   1: saddle
   *   2: maximum
   */

  vtkPointData *pointData = this->GetPointData();
  vtkDataArray *scalarField = pointData->GetArray(fieldId);

  if(!scalarField) return vtkPolyData::ERR_NO_SUCH_FIELD;

  return this->GetScalarFieldCriticalIndex(pointId, scalarField);
}
",16300,True,2786.8226409527656,median
"/**
 * Duration
 * Standalone timeline for Creative Code
 *
 * Copyright (c) 2012 James George
 * Development Supported by YCAM InterLab http://interlab.ycam.jp/en/
 * http://jamesgeorge.org + http://flightphase.com
 * http://github.com/obviousjim + http://github.com/flightphase
 *
 * 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 ""DurationController.h""
#include ""ofxHotKeys.h""

#define DROP_DOWN_WIDTH 250
#define TEXT_INPUT_WIDTH 100

DurationController::DurationController(){
	lastOSCBundleSent = 0;
	shouldStartPlayback = false;
	receivedAddTrack = false;
	receivedPaletteToLoad = false;
	
	enabled = false;
	shouldCreateNewProject = false;
    shouldLoadProject = false;
	audioTrack = NULL;
}

DurationController::~DurationController(){

}

void DurationController::enableInterface(){
	if(!enabled){
		enabled = true;
		ofAddListener(ofEvents().update, this, &DurationController::update);
		ofAddListener(ofEvents().draw, this, &DurationController::draw);
		ofAddListener(ofEvents().keyPressed, this, &DurationController::keyPressed);
		gui->enable();
		gui->disableAppEventCallbacks();
		timeline.enable();
		map<string,ofPtr<ofxTLUIHeader> >::iterator it = headers.begin();
		while(it != headers.end()){
			it->second->getGui()->enable();
			it++;
		}
	}
}

void DurationController::disableInterface(){
	if(enabled){
		enabled = false;
		ofRemoveListener(ofEvents().update, this, &DurationController::update);
		ofRemoveListener(ofEvents().draw, this, &DurationController::draw);
		ofRemoveListener(ofEvents().keyPressed, this, &DurationController::keyPressed);
		gui->disable();
		timeline.disable();
		map<string,ofPtr<ofxTLUIHeader> >::iterator it = headers.begin();
		while(it != headers.end()){
			it->second->getGui()->disable();
			it++;
		}
	}
}

bool DurationController::isInterfaceEnabled(){
	return enabled;
}

void DurationController::setup(){
    
	#ifdef TARGET_WIN32
	FreeConsole();
	#endif
	if(!translation.load(""languageFile.csv"")){
		ofLogError(""DurationController::setup"") << ""error setting up translation, unpredictable stuff will happen"" << endl;
	}
	
	ofxXmlSettings defaultSettings;
	bool settingsLoaded = defaultSettings.loadFile(""settings.xml"");	;
	translation.setCurrentLanguage(defaultSettings.getValue(""language"", ""english""));
	
	if(!settingsLoaded){
		defaultSettings.setValue(""language"", ""english"");
		defaultSettings.saveFile();
	}
	
    //populate projects
    vector<string> projects;
    projects.push_back(translation.translateKey(""new project...""));
    projects.push_back(translation.translateKey(""open project...""));
   
#ifdef TARGET_WIN32
    defaultProjectDirectoryPath = ofToDataPath(ofFilePath::getUserHomeDir() + ""\\\\Documents\\\\Duration\\\\"");
#else
    defaultProjectDirectoryPath = ofToDataPath(ofFilePath::getUserHomeDir() + ""/Documents/Duration/"");
#endif
	ofDirectory projectDirectory = ofDirectory(defaultProjectDirectoryPath);
	
    if(!projectDirectory.exists()){
        projectDirectory.create(true);
    }
    
    projectDirectory.listDir();
    for(int i = 0; i < projectDirectory.size(); i++){
        if(projectDirectory.getFile(i).isDirectory()){
            ofDirectory subDir = ofDirectory(projectDirectory.getPath(i));
			//cout << ""checking path "" << projectDirectory.getPath(i) << endl;
            subDir.allowExt(""durationproj"");
            subDir.setShowHidden(true);
            subDir.listDir();
            if(subDir.size() > 0){
                projects.push_back(projectDirectory.getName(i));
            }
        }
    }
	
#ifdef TARGET_WIN32
	timeline.setupFont(""GUI/mplus-1c-regular.ttf"", 9);
	tooltipFont.loadFont(""GUI/mplus-1c-regular.ttf"", 7);
#else
	timeline.setupFont(""GUI/mplus-1c-regular.ttf"", 6);
	tooltipFont.loadFont(""GUI/mplus-1c-regular.ttf"", 5);
#endif
	//setup timeline
	timeline.setup();
//	timeline.curvesUseBinary = true; //ELOI SWITCH THIS HERE
//	timeline.enableUndo(false);
    timeline.setSpacebarTogglePlay(false);
    timeline.setFrameRate(30);
	timeline.setDurationInSeconds(30);
	timeline.setOffset(ofVec2f(0, 90));
    timeline.setBPM(120.f);
	timeline.setAutosave(false);
	timeline.setEditableHeaders(true);
	timeline.moveToThread(); //increases accuracy of bang call backs
    
	//Set up top GUI
    gui = new ofxUICanvas(0,0,ofGetWidth(), 90);
    
    //ADD PROJECT DROP DOWN
    projectDropDown = new ofxUIDropDownList(DROP_DOWN_WIDTH, ""PROJECT"", projects, OFX_UI_FONT_LARGE);
    projectDropDown->setAutoClose(true);
    gui->addWidgetDown(projectDropDown);
    //ADD TRACKS
    vector<string> trackTypes;
    trackTypes.push_back(translation.translateKey(""bangs""));
    trackTypes.push_back(translation.translateKey(""flags""));
    trackTypes.push_back(translation.translateKey(""switches""));
    trackTypes.push_back(translation.translateKey(""curves""));
    trackTypes.push_back(translation.translateKey(""colors""));
	trackTypes.push_back(translation.translateKey(""lfo""));
	trackTypes.push_back(translation.translateKey(""audio""));
	
    addTrackDropDown = new ofxUIDropDownList(DROP_DOWN_WIDTH, translation.translateKey(""ADD TRACK""), trackTypes, OFX_UI_FONT_MEDIUM);
    addTrackDropDown->setAllowMultiple(false);
    addTrackDropDown->setAutoClose(true);
	//    gui->addWidgetRight(addTrackDropDown);
	gui->addWidgetSouthOf(addTrackDropDown, ""PROJECT"");
	
    saveButton = new ofxUIMultiImageButton(32, 32, false, ""GUI/save_.png"", ""SAVE"");
    saveButton->setLabelVisible(false);
    gui->addWidgetEastOf(saveButton, ""PROJECT"");
    
	
    //ADD TIMECODE
    string zeroTimecode = ""00:00:00:000"";
    timeLabel = new ofxUILabel(zeroTimecode, OFX_UI_FONT_LARGE);
    gui->addWidgetRight(timeLabel);
	//durationLabel = new ofxUILabel("" / ""+zeroTimecode, OFX_UI_FONT_SMALL);
    durationLabel = new ofxUITextInput(""DURATION"", zeroTimecode, timeLabel->getRect()->width,0,0,0,OFX_UI_FONT_MEDIUM);
    durationLabel->setAutoClear(false);
    gui->addWidgetSouthOf(durationLabel, zeroTimecode);
    
    //ADD PLAY/PAUSE
    playpauseToggle = new ofxUIMultiImageToggle(32, 32, false, ""GUI/play_.png"", ""PLAYPAUSE"");
    playpauseToggle->setLabelVisible(false);
    gui->addWidgetEastOf(playpauseToggle, zeroTimecode);
    stopButton = new ofxUIMultiImageButton(32, 32, false, ""GUI/stop_.png"", ""STOP"");
    stopButton->setLabelVisible(false);
    gui->addWidgetRight(stopButton);
	loopToggle = new ofxUIMultiImageToggle(32, 32, false, ""GUI/loop_.png"", ""LOOP"");
	loopToggle->setLabelVisible(false);
    gui->addWidgetRight(loopToggle);
    
	
    //SETUP BPM CONTROLS
	useBPMToggle = new ofxUILabelToggle(translation.translateKey(""BPM""), false);
    gui->addWidgetRight(useBPMToggle);
	bpmDialer = new ofxUINumberDialer(0., 250., 120., 2, ""BPM_VALUE"", OFX_UI_FONT_MEDIUM);
    gui->addWidgetEastOf(bpmDialer, translation.translateKey(""BPM""));
    //figure out where to put this
//	snapToKeysToggle = new ofxUILabelToggle(""Snap to Keys"",false,0,0,00,OFX_UI_FONT_MEDIUM);
//	gui->addWidgetSouthOf(snapToKeysToggle, ""BPM"");
//    snapToBPMToggle = new ofxUILabelToggle(""Snap to BPM"",false,0,0,0,0,OFX_UI_FONT_SMALL);
//    gui->addWidgetSouthOf(snapToBPM, ""BPM"");
    
    //SETUP OSC CONTROLS
    enableOSCInToggle = new ofxUILabelToggle(translation.translateKey(""OSC IN""),false,0,0,0,0, OFX_UI_FONT_MEDIUM);
    enableOSCOutToggle = new ofxUILabelToggle(translation.translateKey(""OSC OUT""),false,0,0,0,0, OFX_UI_FONT_MEDIUM);
    oscOutIPInput = new ofxUITextInput(""OSCIP"", ""127.0.0.1"",TEXT_INPUT_WIDTH*1.5,0,0,0, OFX_UI_FONT_MEDIUM);
    oscOutIPInput->setAutoClear(false);
	
    oscInPortInput = new ofxUITextInput(""OSCINPORT"", ""12346"",TEXT_INPUT_WIDTH*.8,0,0,0, OFX_UI_FONT_MEDIUM);
    oscInPortInput->setAutoClear(false);

    oscOutPortInput = new ofxUITextInput(""OSCOUTPORT"", ""12345"",TEXT_INPUT_WIDTH*.8,0,0,0, OFX_UI_FONT_MEDIUM);
    oscOutPortInput->setAutoClear(false);

	gui->addWidgetRight(enableOSCInToggle);
    gui->addWidgetRight(oscInPortInput);
    gui->addWidgetRight(enableOSCOutToggle);
    gui->addWidgetRight(oscOutIPInput);
    gui->addWidgetRight(oscOutPortInput);

	ofAddListener(gui->newGUIEvent, this, &DurationController::guiEvent);
	
	//add events
    ofAddListener(timeline.events().bangFired, this, &DurationController::bangFired);
	ofAddListener(ofEvents().exit, this, &DurationController::exit);

    //SET UP LISENTERS
	enableInterface();
	
    if(settingsLoaded){
        string lastProjectPath = defaultSettings.getValue(""lastProjectPath"", """");
        string lastProjectName = defaultSettings.getValue(""lastProjectName"", """");
        if(lastProjectPath != """" && lastProjectName != """" && ofDirectory(lastProjectPath).exists()){
            loadProject(lastProjectPath, lastProjectName);
        }
        else{
            ofLogError() << ""Duration -- Last project was not found, creating a new project"";
            loadProject(ofToDataPath(defaultProjectDirectoryPath+""Sample Project""), ""Sample Project"", true);
        }
    }
    else {
//        cout << ""Loading sample project "" << defaultProjectDirectoryPath << endl;
        loadProject(ofToDataPath(defaultProjectDirectoryPath+""Sample Project""), ""Sample Project"", true);
    }

	createTooltips();
	
	startThread();
}

void DurationController::threadedFunction(){
	while(isThreadRunning()){
		lock();
		oscLock.lock();
		handleOscIn();
		handleOscOut();
		oscLock.unlock();
		unlock();
		
		ofSleepMillis(1);
	}
}

void DurationController::handleOscIn(){
	if(!settings.oscInEnabled){
		return;
	}
	
	//TODO: move parsing and receing to separate different threads?
	long timelineStartTime = timeline.getCurrentTimeMillis();
	while(receiver.hasWaitingMessages()){

		ofxOscMessage m;
		receiver.getNextMessage(&m);
		bool handled = false;
		long startTime = recordTimer.getAppTimeMicros();
		vector<ofxTLPage*>& pages = timeline.getPages();
		for(int i = 0; i < pages.size(); i++){
			vector<ofxTLTrack*>& tracks = pages[i]->getTracks();
			for(int t = 0; t < tracks.size(); t++){
//				cout << "" testing against "" << ""/""+tracks[t]->getDisplayName() << endl;
				ofxTLTrack* track = tracks[t];
				ofPtr<ofxTLUIHeader> header = headers[track->getName()];				
				if(header->receiveOSC() && m.getAddress() == ofFilePath::addLeadingSlash(track->getDisplayName()) ){
					
					if(timeline.getIsPlaying() ){ //TODO: change to isPlaying() && isRecording()
						if(track->getTrackType() == ""Curves""){
							ofxTLCurves* curves = (ofxTLCurves*)track;
//							cout << ""adding value "" << m.getArgAsFloat(0) << endl;
							if(m.getArgType(0) == OFXOSC_TYPE_FLOAT){
								float value = m.getArgAsFloat(0);
								if(value != header->lastValueReceived || !header->hasReceivedValue){
									curves->addKeyframeAtMillis(value, timelineStartTime);
									header->lastValueReceived = value;
									header->hasReceivedValue = true;
								}
							}
						}
						else if(track->getTrackType() == ""Bangs""){
							ofxTLBangs* bangs = (ofxTLBangs*)track;
							bangs->addKeyframeAtMillis(0,timelineStartTime);
						}
					}

					header->lastInputReceivedTime = recordTimer.getAppTimeSeconds();
					handled = true;
				}
			}
		}
		
		long endTime = recordTimer.getAppTimeMicros();
//		cout << ""receiving message took "" << (endTime - startTime) << "" micros "" << endl;
		if(handled){
			return;
		}
		
		//check for playback messages
		if(m.getAddress() == ""/duration/open""){
			if(m.getNumArgs() == 1 && m.getArgType(0) == OFXOSC_TYPE_STRING){
				string projectPath = m.getArgAsString(0);
				shouldLoadProject = true;
				if(ofFilePath::isAbsolute(projectPath)){
					projectToLoad = projectPath;
				}
				else{
					projectToLoad = defaultProjectDirectoryPath+projectPath;
				}
			}
			else{
				ofLogError(""Duration:OSC"") << "" Open Project Failed - must have on string argument specifying project name or absolute path"";
			}
		}
		else if(m.getAddress() == ""/duration/new""){
			if(m.getNumArgs() == 1 && m.getArgType(0) == OFXOSC_TYPE_STRING){
				string path = m.getArgAsString(0);
				shouldCreateNewProject = true;
				if(ofFilePath::isAbsolute(path)){
					newProjectPath = path;
				}
				else{
					newProjectPath = defaultProjectDirectoryPath+path;
				}
				cout << ""creating new project at path "" << newProjectPath << endl;
			}
			else{
				ofLogError(""Duration:OSC"") << "" New Project Failed - must have on string argument specifying the new project path"";
			}
		}
		else if(m.getAddress() == ""/duration/save""){
			saveProject();
		}
		else if(m.getAddress() == ""/duration/setduration""){
			if(m.getNumArgs() == 1){
				//seconds
				if(m.getArgType(0) == OFXOSC_TYPE_FLOAT){
					timeline.setDurationInSeconds(m.getArgAsFloat(0));
					durationLabel->setTextString(timeline.getDurationInTimecode());					
				}
				//timecode
				else if(m.getArgType(0) == OFXOSC_TYPE_STRING){
					timeline.setDurationInTimecode(m.getArgAsString(0));
					durationLabel->setTextString(timeline.getDurationInTimecode());
				}
				//millis
				else if(m.getArgType(0) == OFXOSC_TYPE_INT32){
					timeline.setDurationInMillis(m.getArgAsInt32(0));
					durationLabel->setTextString(timeline.getDurationInTimecode());					
				}
				else if(m.getArgType(0) == OFXOSC_TYPE_INT64){
					timeline.setDurationInMillis(m.getArgAsInt64(0));
					durationLabel->setTextString(timeline.getDurationInTimecode());
				}
			}
			else {
				ofLogError(""Duration:OSC"") << "" Set Duration failed - must have one argument. seconds as float, timecode string HH:MM:SS:MILS, or integer as milliseconds"";
			}
		}
		else if(m.getAddress() == ""/duration/play""){
			if(m.getNumArgs() == 0){
				if(!timeline.getIsPlaying()){
					shouldStartPlayback = true;
				}
			}
			else {
				for(int i = 0; i < m.getNumArgs(); i++){
					if(m.getArgType(i) == OFXOSC_TYPE_STRING){
						ofPtr<ofxTLUIHeader> header = getHeaderWithDisplayName(m.getArgAsString(i));
						if(header != NULL){
							header->getTrack()->play();
						}
					}
				}
			}
		}
		else if(m.getAddress() == ""/duration/stop""){
			if(m.getNumArgs() == 0){
				if(timeline.getIsPlaying()){
					timeline.stop();
				}
				else{
					timeline.setCurrentTimeMillis(0);
				}
			}
			else{
				for(int i = 0; i < m.getNumArgs(); i++){
					if(m.getArgType(i) == OFXOSC_TYPE_STRING){
						ofPtr<ofxTLUIHeader> header = getHeaderWithDisplayName(m.getArgAsString(i));
						if(header != NULL){
							header->getTrack()->stop();
						}
					}
				}				
			}
		}
		else if(m.getAddress() == ""/duration/record""){
			//TODO: turn on record mode
			shouldStartPlayback = true;
			//startPlayback();
		}
		else if(m.getAddress() == ""/duration/seektosecond""){
			if(m.getArgType(0) == OFXOSC_TYPE_FLOAT){
				timeline.setCurrentTimeSeconds(m.getArgAsFloat(0));
			}
			else{
				ofLogError(""Duration:OSC"") << "" Seek to Second failed: first argument must be a float"";
			}
		}
		else if(m.getAddress() == ""/duration/seektoposition""){
			if(m.getArgType(0) == OFXOSC_TYPE_FLOAT){
				float percent = ofClamp(m.getArgAsFloat(0),0.0,1.0);
				timeline.setPercentComplete(percent);
			}
			else{
				ofLogError(""Duration:OSC"") << "" Seek to Position failed: first argument must be a float between 0.0 and 1.0"";
			}
		}
		else if(m.getAddress() == ""/duration/seektomillis""){
			if(m.getArgType(0) == OFXOSC_TYPE_INT32){
				timeline.setCurrentTimeMillis(m.getArgAsInt32(0));
			}
			else if(m.getArgType(0) == OFXOSC_TYPE_INT64){
				timeline.setCurrentTimeMillis(m.getArgAsInt64(0));
			}
			else{
				ofLogError(""Duration:OSC"") << "" Seek to Millis failed: first argument must be a int 32 or in 64"";
			}
		}
		else if(m.getAddress() == ""/duration/seektotimecode""){
			if(m.getArgType(0) == OFXOSC_TYPE_STRING){
				long millis = ofxTimecode::millisForTimecode(m.getArgAsString(0));
				if(millis > 0){
					timeline.setCurrentTimeMillis(millis);
				}
				else{
					ofLogError(""Duration:OSC"") << "" Seek to Timecode failed: bad timecode. Please format HH:MM:SS:MMM"";
				}
			}
			else{
				ofLogError(""Duration:OSC"") << "" Seek to Timecode failed: first argument must be a string"";
			}
		}
		//enable and disable OSC
		else if(m.getAddress() == ""/duration/enableoscout""){
			//system wide
			if(m.getNumArgs() == 1 && m.getArgType(0) == OFXOSC_TYPE_INT32){
				settings.oscOutEnabled = m.getArgAsInt32(0) != 0;
				enableOSCOutToggle->setValue(settings.oscOutEnabled);
			}
			//per track
			else if(m.getNumArgs() == 2 &&
					m.getArgType(0) == OFXOSC_TYPE_STRING &&
					m.getArgType(1) == OFXOSC_TYPE_INT32)
			{
				string trackName = m.getArgAsString(0);
				ofPtr<ofxTLUIHeader> header = getHeaderWithDisplayName(trackName);
				if(header != NULL){
					header->setSendOSC(m.getArgAsInt32(1) != 0);
				}
				else {
					ofLogError(""Duration:OSC"") << "" Enable OSC out failed. track not found "" << trackName;
				}
			}
			else{
				ofLogError(""Duration:OSC"") << "" Enable OSC out incorrectly formatted arguments. usage: /duration/enableoscout enable:int32 == (1 or 0), or /duration/enableoscout trackname:string enable:int32 (1 or 0)"";
			}
		}
		else if(m.getAddress() == ""/duration/oscrate""){
			if(m.getNumArgs() == 1){
				if(m.getArgType(0) == OFXOSC_TYPE_INT32){
					settings.oscRate = m.getArgAsInt32(0);
					oscFrequency = 1000*1/settings.oscRate;
				}
				else if(m.getArgType(0) == OFXOSC_TYPE_INT64){
					settings.oscRate = m.getArgAsInt64(0);
					oscFrequency = 1000*1/settings.oscRate;
				}
				else if(m.getArgType(0) == OFXOSC_TYPE_FLOAT){
					settings.oscRate = m.getArgAsFloat(0);
					oscFrequency = 1000*1/settings.oscRate;
				}
				else {
					ofLogError(""Duration:OSC"") << "" Set OSC rate failed. must specify an int or a float as the first parameter"";
				}
			}
		}
		else if(m.getAddress() == ""/duration/enableoscin""){
			//system wide -- don't quite know what to do as this will turn off all osc
			if(m.getNumArgs() == 1 && m.getArgType(0) == OFXOSC_TYPE_INT32){
				settings.oscInEnabled = m.getArgAsInt32(0) != 0;
				enableOSCInToggle->setValue(settings.oscInEnabled);
			}
			//per track
			else if(m.getNumArgs() == 2 && m.getArgType(0) == OFXOSC_TYPE_STRING && m.getArgType(1) == OFXOSC_TYPE_INT32){
				string trackName = m.getArgAsString(0);
				ofPtr<ofxTLUIHeader> header = getHeaderWithDisplayName(trackName);
				if(header != NULL){
					header->setReceiveOSC(m.getArgAsInt32(1) == 1);
				}
				else {
					ofLogError(""Duration:OSC"") << "" Enable in out failed. track not found "" << trackName;
				}
			}
			else{
				ofLogError(""Duration:OSC"") << ""Enable OSC in incorrectly formatted arguments. usage: /duration/enableoscout enable:int32 == (1 or 0), or /duration/enableoscout trackname:string enable:int32 (1 or 0)"";
			}
		}		
		//adding and removing tracks
		else if(m.getAddress() == ""/duration/addtrack""){
			//type,
			receivedAddTrack = false;
			oscTrackTypeReceived = """";
			oscTrackNameReceived = """";
			oscTrackFilePathReceived = """";
			//type
			if(m.getNumArgs() > 0 && m.getArgType(0) == OFXOSC_TYPE_STRING) {
				oscTrackTypeReceived = m.getArgAsString(0);
				receivedAddTrack = true;
			}
			//type, name
			if(m.getNumArgs() > 1 &&m.getArgType(1) == OFXOSC_TYPE_STRING) {
				oscTrackNameReceived = m.getArgAsString(1);
				receivedAddTrack = true;
			}
			//type, name, file path
			if(m.getNumArgs() > 2 && m.getArgType(2) == OFXOSC_TYPE_STRING)
			{
				oscTrackFilePathReceived = m.getArgAsString(2);
				receivedAddTrack = true;
			}
			if(!receivedAddTrack){
				ofLogError(""Duration:OSC"") << ""Add track failed, incorrectly formatted arguments. \\n usage: /duration/addtrack type:string [optional name:string ] [optional filepath:string ]"";
			}
		}
		else if(m.getAddress() == ""/duration/removetrack""){
			if(m.getNumArgs() == 1 && m.getArgType(0) == OFXOSC_TYPE_STRING){
				string trackName = m.getArgAsString(0);
				ofPtr<ofxTLUIHeader> header = getHeaderWithDisplayName(trackName);
				if(header != NULL){
					header->setShouldDelete(true);
				}
				else{
					ofLogError(""Duration:OSC"") << ""Remove track failed, could not find track "" << trackName;
				}
			}
			else {
				ofLogError(""Duration:OSC"") << ""Remove track failed, incorrectly formatted arguments. \\n usage: /duration/removetrack name:string"";
			}
		}
		else if(m.getAddress() == ""/duration/trackname""){
			if(m.getNumArgs() == 2 &&
			   m.getArgType(0) == OFXOSC_TYPE_STRING &&
			   m.getArgType(1) == OFXOSC_TYPE_STRING)
			{
				string trackName = m.getArgAsString(0);
				ofPtr<ofxTLUIHeader> header = getHeaderWithDisplayName(trackName);
				if(header != NULL){
					header->getTrack()->setDisplayName(m.getArgAsString(1));
				}
				else{
					ofLogError(""Duration:OSC"") << ""Set Track Name failed, could not find track "" << trackName;
				}
			}
			else{
				ofLogError(""Duration:OSC"") << ""Set Track Name failed, incorrectly formatted arguments. \\n usage: /duration/trackname oldname:string newname:string"";
			}
		}
		else if(m.getAddress() == ""/duration/valuerange""){
			if(m.getNumArgs() == 3 &&
			   m.getArgType(0) == OFXOSC_TYPE_STRING && //track name
			   m.getArgType(1) == OFXOSC_TYPE_FLOAT && //min
			   m.getArgType(2) == OFXOSC_TYPE_FLOAT) //max
			{
				string trackName = m.getArgAsString(0);
				ofPtr<ofxTLUIHeader> header = getHeaderWithDisplayName(trackName);
				if(header != NULL){
					if(header->getTrackType() == ""Curves"" || header->getTrackType() == ""LFO""){
						header->setValueRange(ofRange(m.getArgAsFloat(1),m.getArgAsFloat(2)));
					}
					else {
						ofLogError(""Duration:OSC"") << ""Set value range failed, track is not a Curves track "" << trackName;
					}
				}
				else{
					ofLogError(""Duration:OSC"") << ""Set value range failed, could not find track "" << trackName;
				}
			}
			else {
				ofLogError(""Duration:OSC"") << ""Set value range failed, incorrectly formatted message. \\n usage: /duration/valuerange trackname:string min:float max:float"";
			}
		}
		else if(m.getAddress() == ""/duration/valuerange/min""){
			if(m.getNumArgs() == 2 &&
			   m.getArgType(0) == OFXOSC_TYPE_STRING && //track name
			   m.getArgType(1) == OFXOSC_TYPE_FLOAT) //min
			{
				string trackName = m.getArgAsString(0);
				ofPtr<ofxTLUIHeader> header = getHeaderWithDisplayName(trackName);
				if(header != NULL){
					if(header->getTrackType() == ""Curves"" || header->getTrackType() == ""LFO""){
						header->setValueMin(m.getArgAsFloat(1));
					}
					else{
						ofLogError(""Duration:OSC"") << ""Set value range min failed, track is not a Curves track "" << trackName;
					}
				}
				else{
					ofLogError(""Duration:OSC"") << ""Set value range min failed, could not find track "" << trackName;
				}
			}
			else{
				ofLogError(""Duration:OSC"") << ""Set value range min failed. Incorrectly formatted arguments \\n usage: /duration/valuerange/min trackname:string"";
			}
		}
		else if(m.getAddress() == ""/duration/valuerange/max""){
			if(m.getNumArgs() == 2 &&
			   m.getArgType(0) == OFXOSC_TYPE_STRING && //track name
			   m.getArgType(1) == OFXOSC_TYPE_FLOAT) //max
			{
				string trackName = m.getArgAsString(0);
				ofPtr<ofxTLUIHeader> header = getHeaderWithDisplayName(trackName);
				if(header != NULL){
					if(header->getTrackType() == ""Curves"" || header->getTrackType() == ""LFO""){
						header->setValueMax(m.getArgAsFloat(1));
					}
					else{
						ofLogError(""Duration:OSC"") << ""Set value range max failed, track is not a Curves track "" << trackName;
					}
				}
				else{
					ofLogError(""Duration:OSC"") << ""Set value range min failed, could not find track "" << trackName;
				}
			}
			else{
				ofLogError(""Duration:OSC"") << ""Set value range min failed. Incorrectly formatted arguments \\n usage: /duration/valuerange/min trackname:string"";
			}
		}
		else if(m.getAddress() == ""/duration/colorpalette""){
			if(m.getNumArgs() == 2 &&
			   m.getArgType(0) == OFXOSC_TYPE_STRING && //track name
			   m.getArgType(1) == OFXOSC_TYPE_STRING) //file path
			{
				string trackName = m.getArgAsString(0);
				ofPtr<ofxTLUIHeader> header = getHeaderWithDisplayName(trackName);
				if(header != NULL){
					if(header->getTrackType() == ""Colors""){
						receivedPaletteToLoad = true;
						paletteTrack = (ofxTLColorTrack*)header->getTrack();
						palettePath  = m.getArgAsString(1);
					}
				}
				else {
					ofLogError(""Duration:OSC"") << ""Set color palette failed, could not find track "" << trackName;
				}
			}
			else{
				ofLogError(""Duration:OSC"") << ""Set color palette failed, incorrectly formatted arguments \\n usage: /duration/colorpalette trackname:string imagefilepath:string"";
			}
		}
		else if(m.getAddress() == ""/duration/audioclip""){
			if(m.getNumArgs() == 1 && m.getArgType(0) == OFXOSC_TYPE_STRING){
				if(audioTrack != NULL){
					if(!audioTrack->loadSoundfile(m.getArgAsString(0))){
						ofLogError(""Duration:OSC"") << ""Set audio clip failed, clip failed to load. "" << m.getArgAsString(0);
					}
				}
				else {
					ofLogError(""Duration:OSC"") << ""Set audio clip failed, first add an audio track to the composition."";
				}
			}
			else{
				ofLogError(""Duration:OSC"") << ""Set audio clip failed, incorrectly formatted arguments. \\n usage /duration/audioclip filepath:string "";
			}
		}
	}
}

void DurationController::handleOscOut(){
	
	if(!settings.oscOutEnabled){
		return;
	}
	
	unsigned long bundleTime = recordTimer.getAppTimeMillis();
	if(lastOSCBundleSent+oscFrequency > bundleTime){
		return;
	}
	//cout << ""OSC RATE IS "" << settings.oscRate << "" osc FREQUENCY is "" << oscFrequency << "" sending num at record timer "" << recordTimer.getAppTimeMillis() << endl;
	
	unsigned long timelineSampleTime = timeline.getCurrentTimeMillis();
	int numMessages = 0;
	ofxOscBundle bundle;
	
	//lock();
	vector<ofxTLPage*>& pages = timeline.getPages();
	for(int i = 0; i < pages.size(); i++){
		vector<ofxTLTrack*>& tracks = pages[i]->getTracks();
		for(int t = 0; t < tracks.size(); t++){
			ofPtr<ofxTLUIHeader> header = headers[tracks[t]->getName()];
			if(!header->sendOSC()){
				continue;
			}
			unsigned long trackSampleTime = tracks[t]->getIsPlaying() ? tracks[t]->currentTrackTime() : timelineSampleTime;
			string trackType = tracks[t]->getTrackType();
			if(trackType == ""Curves"" || trackType == ""Switches"" || trackType == ""Colors"" || trackType == ""Audio"" || trackType == ""LFO""){
				bool messageValid = false;
				ofxOscMessage m;
				if(trackType == ""Curves"" || trackType == ""LFO""){
					ofxTLKeyframes* curves = (ofxTLKeyframes*)tracks[t];
					float value = curves->getValueAtTimeInMillis(trackSampleTime);
					if(value != header->lastFloatSent || !header->hasSentValue || refreshAllOscOut){
						m.addFloatArg(value);
						header->lastFloatSent = value;
						header->hasSentValue = true;
						messageValid = true;
					}
				}
				else if(trackType == ""Switches""){
					ofxTLSwitches* switches = (ofxTLSwitches*)tracks[t];
					bool on = switches->isOnAtMillis(trackSampleTime);
					if(on != header->lastBoolSent || !header->hasSentValue || refreshAllOscOut){
						m.addIntArg(on ? 1 : 0);
						header->lastBoolSent = on;
						header->hasSentValue = true;
						messageValid = true;
					}
				}
				else if(trackType == ""Colors""){
					ofxTLColorTrack* colors = (ofxTLColorTrack*)tracks[t];
					ofColor color = colors->getColorAtMillis(trackSampleTime);
					if(color != header->lastColorSent || !header->hasSentValue || refreshAllOscOut){
						m.addIntArg(color.r);
						m.addIntArg(color.g);
						m.addIntArg(color.b);
						header->lastColorSent = color;
						header->hasSentValue = true;
						messageValid = true;
					}
				}
				else if(trackType == ""Audio""){
					ofxTLAudioTrack* audio = (ofxTLAudioTrack*)tracks[t];
					if(audio->getIsPlaying() || timeline.getIsPlaying()){
						vector<float>& bins = audio->getFFT();
						for(int b = 0; b < bins.size(); b++){
							m.addFloatArg(bins[b]);
						}
						messageValid = true;
					}
				}
				if(messageValid){
					m.setAddress(ofFilePath::addLeadingSlash(tracks[t]->getDisplayName()));
					bundle.addMessage(m);
					numMessages++;
				}
			}
		}
	}
	//unlock();
	
	//any bangs that came our way this frame send them out too
	for(int i = 0; i < bangsReceived.size(); i++){
//		cout << ""FOUND BANGS!"" << endl;
		bundle.addMessage(bangsReceived[i]);
	}
	numMessages += bangsReceived.size();
	if(numMessages > 0){
		sender.sendBundle(bundle);
		refreshAllOscOut = false;

	}
	lastOSCBundleSent = bundleTime;
	bangsReceived.clear();	
}

//TODO: hook up to record button
//and make NO LOOP 
void DurationController::startRecording(){
	recordTimer.setStartTime();
	recordTimeOffset = timeline.getCurrentTimeMillis();
	//timeline.play();
	startPlayback();
}

void DurationController::stopRecording(){

}

//--------------------------------------------------------------
void DurationController::bangFired(ofxTLBangEventArgs& bang){
// 	ofLogNotice() << ""Bang from "" << bang.track->getDisplayName() << "" at time "" << bang.currentTime << "" with flag "" << bang.flag;
	if(!settings.oscOutEnabled){
		return;
	}
	
    string trackType = bang.track->getTrackType();
    if(!headers[bang.track->getName()]->sendOSC()){
        return;
    }
    ofxOscMessage m;
    m.setAddress( ofFilePath::addLeadingSlash(bang.track->getDisplayName()) );

    if(trackType == ""Flags""){
        m.addStringArg(bang.flag);
    }

	bangsReceived.push_back(m);	
}

//--------------------------------------------------------------
void DurationController::guiEvent(ofxUIEventArgs &e){
    string name = e.widget->getName();
	int kind = e.widget->getKind();
    
	//	cout << ""name is "" << name << "" kind is "" << kind << endl;
    
	if(e.widget == stopButton && stopButton->getValue()){
		if(timeline.getIsPlaying()){
	        timeline.stop();
		}
		else{
	        timeline.setCurrentTimeMillis(0);
		}
    }
    else if(name == ""PLAYPAUSE""){
		if(!timeline.getIsPlaying()){
			startPlayback();
		}
		else{
			timeline.stop();
		}
    }
    else if(name == ""DURATION""){
		if(!gui->hasKeyboardFocus()){
			string newDuration = durationLabel->getTextString();
			timeline.setDurationInTimecode(newDuration);
			durationLabel->setTextString(timeline.getDurationInTimecode());
			needsSave = true;
		}
    }
    else if(e.widget == addTrackDropDown){
        if(addTrackDropDown->isOpen()){
            timeline.disable();
        }
        else {
            timeline.enable();
            if(addTrackDropDown->getSelected().size() > 0){
				lock();
                string selectedTrackType = addTrackDropDown->getSelected()[0]->getName();
				addTrack(translation.keyForTranslation(selectedTrackType));
				unlock();
				
                addTrackDropDown->clearSelected();
            }
        }
    }
    else if(e.widget == projectDropDown){
        if(projectDropDown->isOpen()){
            timeline.disable();
			addTrackDropDown->setVisible(false);
        }
		else {
			addTrackDropDown->setVisible(true);
			addTrackDropDown->close();
            timeline.enable();
            if(projectDropDown->getSelected().size() > 0){
                string selectedProjectName = projectDropDown->getSelected()[0]->getName();
                if(selectedProjectName == translation.translateKey(""new project..."")){
                    shouldCreateNewProject = true;
                }
                else if(selectedProjectName == translation.translateKey(""open project..."")){
                    shouldLoadProject = true;
					projectToLoad = """";
                }
                else {
					shouldLoadProject = true;
					projectToLoad = ofToDataPath(defaultProjectDirectoryPath+selectedProjectName);
                }
                projectDropDown->clearSelected();
            }
        }
    }
    else if(e.widget == saveButton && saveButton->getValue()){
        saveProject();
    }
    //LOOP
    else if(e.widget == loopToggle){
        timeline.setLoopType(loopToggle->getValue() ? OF_LOOP_NORMAL : OF_LOOP_NONE);
		needsSave = true;
    }
    //BPM
	else if(e.widget == bpmDialer){
		if(settings.bpm != bpmDialer->getValue()){
	    	timeline.setBPM(settings.bpm = bpmDialer->getValue());
			needsSave = true;
		}
	}
    else if(e.widget == useBPMToggle){
        settings.useBPM = useBPMToggle->getValue();
        timeline.setShowBPMGrid(settings.useBPM);
        timeline.enableSnapToBPM(settings.useBPM);
		needsSave = true;
    }
	else if(e.widget == snapToKeysToggle){
		timeline.enableSnapToOtherKeyframes(snapToKeysToggle->getValue());
	}
    //OSC INPUT
    else if(e.widget == enableOSCInToggle){
		settings.oscInEnabled = enableOSCInToggle->getValue();
        if(settings.oscInEnabled){
			oscLock.lock();
            receiver.setup(settings.oscInPort);
			oscLock.unlock();
        }
		needsSave = true;		
    }
	//INCOMING PORT
	else if(e.widget == oscInPortInput){
		if(!gui->hasKeyboardFocus()){
			int newPort = ofToInt(oscInPortInput->getTextString());
			if(newPort > 0 && newPort < 65535 &&
			   newPort != settings.oscInPort &&
			   //don't send messages to ourself
			   (newPort != settings.oscOutPort || (settings.oscIP != ""localhost"" && settings.oscIP != ""127.0.0.1""))){
				settings.oscInPort = newPort;
				oscLock.lock();
				receiver.setup(settings.oscInPort);
				oscLock.unlock();
				needsSave = true;
			}
			else {
				oscInPortInput->setTextString( ofToString(settings.oscInPort) );
			}
		}
    }
	
	//OSC OUTPUT
    else if(e.widget == enableOSCOutToggle){
		settings.oscOutEnabled = enableOSCOutToggle->getValue();
        if(settings.oscOutEnabled){
			oscLock.lock();
            sender.setup(settings.oscIP, settings.oscOutPort);
			oscLock.unlock();
			needsSave = true;			
        }
    }

	//OUTGOING IP
    else if(e.widget == oscOutIPInput && !gui->hasKeyboardFocus()){
        string newIP = ofToLower(oscOutIPInput->getTextString());
        if(newIP == settings.oscIP){
            return;
        }
		
        bool valid = (newIP == ""localhost"");
		if(!valid){
			vector<string> ipComponents = ofSplitString(newIP, ""."");
			if(ipComponents.size() == 4){
				valid = true;
				for(int i = 0; i < 4; i++){
					int component = ofToInt(ipComponents[i]);
					if (component < 0 || component > 255){
						valid = false;
						break;
					}
				}
			}
		}

		if((newIP == ""127.0.0.1"" || newIP == ""localhost"") && settings.oscInPort == settings.oscOutPort){
			//don't allow us to send messages to ourself
			valid = false;
		}
		
		if(valid){
			settings.oscIP = newIP;
			oscLock.lock();
			sender.setup(settings.oscIP, settings.oscOutPort);
			oscLock.unlock();
			needsSave = true;			
		}
		oscOutIPInput->setTextString(settings.oscIP);
    }
	//OUTGOING PORT
	else if(e.widget == oscOutPortInput && !gui->hasKeyboardFocus()){
        int newPort = ofToInt(oscOutPortInput->getTextString());
        if(newPort > 0 && newPort < 65535 &&
		   newPort != settings.oscOutPort &&
		   //don't send messages to ourself
		   (newPort != settings.oscInPort || (settings.oscIP != ""localhost"" && settings.oscIP != ""127.0.0.1""))){
            settings.oscOutPort = newPort;
			oscLock.lock();
			sender.setup(settings.oscIP, settings.oscOutPort);
			oscLock.unlock();
			needsSave = true;			
        }
        else {
            oscOutPortInput->setTextString( ofToString(settings.oscOutPort) );
        }
    }
}

//--------------------------------------------------------------
ofxTLTrack* DurationController::addTrack(string trackType, string trackName, string xmlFileName){
	ofxTLTrack* newTrack = NULL;
	
	trackType = ofToLower(trackType);
	if(trackName == """"){
		trackName = trackType;
	}

	if(xmlFileName == """"){
		string uniqueName = timeline.confirmedUniqueName(trackName);
		xmlFileName = ofToDataPath(settings.path + ""/"" + uniqueName + ""_.xml"");
	}
	
	if(trackType == translation.translateKey(""bangs"") || trackType == ""bangs""){
		newTrack = timeline.addBangs(trackName, xmlFileName);
	}
	else if(trackType == translation.translateKey(""flags"") || trackType == ""flags""){
		newTrack = timeline.addFlags(trackName, xmlFileName);
	}
	else if(trackType == translation.translateKey(""curves"") || trackType == ""curves""){
		newTrack = timeline.addCurves(trackName, xmlFileName);
	}
	else if(trackType == translation.translateKey(""switches"")|| trackType == ""switches""){
		newTrack = timeline.addSwitches(trackName, xmlFileName);
	}
	else if(trackType == translation.translateKey(""colors"") || trackType == ""colors""){
		newTrack = timeline.addColors(trackName, xmlFileName);
	}
	else if(trackType == translation.translateKey(""lfo"") || trackType == ""lfo""){
		newTrack = timeline.addLFO(trackName, xmlFileName);
	}
	else if(trackType == translation.translateKey(""audio"") || trackType == ""audio""){
		if(audioTrack != NULL){
			ofLogError(""DurationController::addTrack"") << ""Trying to add an additional audio track"";
		}
		else{
			audioTrack = new ofxTLAudioTrack();
			timeline.addTrack(trackName, audioTrack);
			timeline.bringTrackToTop(audioTrack);
			newTrack = audioTrack;
		}
	}
	else {
		ofLogError(""DurationController::addTrack"") << ""Unsupported track type: "" << trackType;
	}
	
	if(newTrack != NULL){
		createHeaderForTrack(newTrack);
		needsSave = true;
	}
	return newTrack;
}

//--------------------------------------------------------------
void DurationController::update(ofEventArgs& args){
	gui->update();
	
	if(shouldStartPlayback){
		shouldStartPlayback = false;
		startPlayback();
	}
	timeLabel->setLabel(timeline.getCurrentTimecode());
	playpauseToggle->setValue(timeline.getIsPlaying());

	if(audioTrack != NULL && audioTrack->isSoundLoaded()){
		
		if(timeline.getTimecontrolTrack() != audioTrack){
			timeline.setTimecontrolTrack(audioTrack);
		}

		if(audioTrack->getDuration() != timeline.getDurationInSeconds()){
			timeline.setDurationInSeconds(audioTrack->getDuration());
		}
		
		if(durationLabel->getTextString() != timeline.getDurationInTimecode()){
			durationLabel->setTextString(timeline.getDurationInTimecode());
		}
	}
	
	if(ofGetHeight() < timeline.getDrawRect().getMaxY()){
		ofSetWindowShape(ofGetWidth(), timeline.getDrawRect().getMaxY()+30);
	}
    if(shouldLoadProject){
        shouldLoadProject = false;
		if(projectToLoad != """"){
			loadProject(projectToLoad);
			projectToLoad = """";
		}
		else{
			ofFileDialogResult r = ofSystemLoadDialog(""Load Project"", true);
			if(r.bSuccess){
				loadProject(r.getPath(), r.getName());
			}
		}
    }
    
    if(shouldCreateNewProject){
        shouldCreateNewProject = false;
		if(newProjectPath != """"){
			newProject(newProjectPath);
			newProjectPath = """";
		}
		else{
			ofFileDialogResult r = ofSystemSaveDialog(""New Project"", ""NewDuration"");
			if(r.bSuccess){
				newProject(r.getPath(), r.getName());
			}
		}
    }

	if(receivedPaletteToLoad){
		receivedPaletteToLoad = false;
		if(!paletteTrack->loadColorPalette(palettePath)){
			ofLogError(""Duration:OSC"") << ""Set color palette failed, file not found"";
		}
	}

	if(receivedAddTrack){
		lock();
		receivedAddTrack = false;
		addTrack(oscTrackTypeReceived, oscTrackNameReceived, oscTrackFilePathReceived);
		unlock();
	}
    
    //check if we deleted an element this frame
    map<string,ofPtr<ofxTLUIHeader> >::iterator it = headers.begin();
    while(it != headers.end()){
		
		needsSave |= it->second->getModified();
		
		if(timeline.isModal() && it->second->getGui()->isEnabled()){
			it->second->getGui()->disable();
		}
		else if(!timeline.isModal() && !it->second->getGui()->isEnabled()){
			it->second->getGui()->enable();
		}
		
		if(it->second->getShouldDelete()){
			lock();
            timeline.removeTrack(it->first);
			timeline.setTimecontrolTrack(NULL);
			if(it->second->getTrackType() == ""Audio""){
				if(audioTrack == NULL){
					ofLogError(""Audio track inconsistency"");
				}
				else{
					delete audioTrack;
					audioTrack = NULL;
				}
			}
            headers.erase(it);
			unlock();
			needsSave = true;
            break;
        }
        it++;
    }
}

//--------------------------------------------------------------
ofPtr<ofxTLUIHeader> DurationController::getHeaderWithDisplayName(string name){
	map<string, ofPtr<ofxTLUIHeader> >::iterator trackit;
	for(trackit = headers.begin(); trackit != headers.end(); trackit++){
		if(trackit->second->getTrack()->getDisplayName() == name){
			return trackit->second;
		}
	}
	//same as null
	return ofPtr<ofxTLUIHeader>();
}

//--------------------------------------------------------------
void DurationController::draw(ofEventArgs& args){

	//go through and draw all the overlay backgrounds to indicate 'hot' track sfor recording
	ofPushStyle();
	map<string, ofPtr<ofxTLUIHeader> >::iterator trackit;
	for(trackit = headers.begin(); trackit != headers.end(); trackit++){
		//TODO: check to make sure recording is enabled on this track
		//TODO: find a way to illustrate 'invalid' output sent to this track
		float timeSinceInput = recordTimer.getAppTimeSeconds() - trackit->second->lastInputReceivedTime;
		if(timeSinceInput > 0 && timeSinceInput < 1.0){
			//oscilating red to indicate active
			ofSetColor(200,20,0,(1-timeSinceInput)*(80 + (20*sin(ofGetElapsedTimef()*8)*.5+.5)));
			ofRect(trackit->second->getTrack()->getDrawRect());
		}
	}
	ofPopStyle();
	
	timeline.draw();
	gui->draw();

	if(needsSave || timeline.hasUnsavedChanges()){
		ofPushStyle();
		ofSetColor(200,20,0, 40);
		ofFill();
		ofRect(*saveButton->getRect());
		ofPopStyle();
	}
	drawTooltips();
	//drawTooltipDebug();
}

//--------------------------------------------------------------
void DurationController::keyPressed(ofKeyEventArgs& keyArgs){
    if(timeline.isModal()){
        return;
    }
	
	if(gui->hasKeyboardFocus()){
		return;
	}
	
    int key = keyArgs.key;
	if(key == ' '){
		if(ofGetModifierShiftPressed()){
			timeline.togglePlaySelectedTrack();
		}
		else{
			if(!timeline.getIsPlaying()){
				startPlayback();
			}
			else{
				timeline.stop();
			}
		}
    }
    
    if(key == 'i'){
		if(ofGetModifierAltPressed()){
			timeline.setInPointAtMillis(0);
		}
		else{
	        timeline.setInPointAtPlayhead();
		}
    }
    
    if(key == 'o'){
		if(ofGetModifierAltPressed()){
			timeline.setOutPointAtPercent(1.0);
		}
		else{
	        timeline.setOutPointAtPlayhead();
		}
    }
	
	
	if(ofGetModifierShortcutKeyPressed() && (key == 's' || key=='s'-96) ){
		saveProject();
	}
	
}

//--------------------------------------------------------------
void DurationController::startPlayback(){
	if(!timeline.getIsPlaying()){
		sendInfoMessage();
		timeline.play();
	}
}

//--------------------------------------------------------------
void DurationController::sendInfoMessage(){
	if(settings.oscOutEnabled){
		ofxOscMessage m;
		m.setAddress(""/duration/info"");		
		vector<ofxTLPage*>& pages = timeline.getPages();
		for(int i = 0; i < pages.size(); i++){
			vector<ofxTLTrack*>& tracks = pages[i]->getTracks();
			for (int t = 0; t < tracks.size(); t++) {
				m.addStringArg(tracks[t]->getTrackType());
				m.addStringArg(ofFilePath::addLeadingSlash( tracks[t]->getDisplayName() ));
				if(tracks[t]->getTrackType() == ""Curves"" || tracks[t]->getTrackType() == ""LFO""){
					ofxTLCurves* curves = (ofxTLCurves*)tracks[t];
					m.addFloatArg(curves->getValueRange().min);
					m.addFloatArg(curves->getValueRange().max);
				}
			}
		}
		oscLock.lock();
		sender.sendMessage(m);
		refreshAllOscOut = true;
		oscLock.unlock();
	}
}

//--------------------------------------------------------------
DurationProjectSettings DurationController::defaultProjectSettings(){
    DurationProjectSettings settings;
    
    settings.name = ""newProject"";
    settings.path = defaultProjectDirectoryPath + settings.name;
    
    settings.useBPM = false;
    settings.bpm = 120.0f;
    settings.snapToBPM = false;
    settings.snapToKeys = true;
    
	settings.oscRate = 30;
    settings.oscOutEnabled = true;
	settings.oscInEnabled = true;
    settings.oscInPort = 12346;
    settings.oscIP = ""localhost"";
    settings.oscOutPort = 12345;
    return settings;
}

//--------------------------------------------------------------
void DurationController::newProject(string projectPath){
	//scrape off the last component of the filename for the project name
	projectPath = ofFilePath::removeTrailingSlash(projectPath);
#ifdef TARGET_WIN32
	vector<string> pathComponents = ofSplitString(projectPath, ""\\\\"");
#else
	vector<string> pathComponents = ofSplitString(projectPath, ""/"");
#endif
	newProject(projectPath, pathComponents[pathComponents.size()-1]);
}

//--------------------------------------------------------------
void DurationController::newProject(string newProjectPath, string newProjectName){
    DurationProjectSettings newProjectSettings = defaultProjectSettings();
    newProjectSettings.name = newProjectName;
    newProjectSettings.path = ofToDataPath(newProjectPath);
    newProjectSettings.settingsPath = ofToDataPath(newProjectSettings.path + ""/.durationproj"");
#ifdef TARGET_WIN32
	ofStringReplace(newProjectSettings.path,""/"", ""\\\\"");
#endif
    ofDirectory newProjectDirectory(newProjectSettings.path);
    if(newProjectDirectory.exists()){
    	ofSystemAlertDialog(translation.translateKey(""Error creating new project. The folder already exists."")+"" "" + newProjectSettings.path);
        return;
    }
    if(!newProjectDirectory.create(true)){
    	ofSystemAlertDialog(translation.translateKey(""Error creating new project. The folder could not be created."")+"" "" + newProjectSettings.path);
        return;
    }
    
    //TODO: prompt to save existing project
    settings = newProjectSettings;
	lock();
    headers.clear(); //smart pointers will call destructor
    timeline.reset();
	unlock();
	
    //saves file with default settings to new directory
    saveProject();
    
    loadProject(settings.path, settings.name);
    
    projectDropDown->addToggle(newProjectName);
}

//--------------------------------------------------------------
void DurationController::loadProject(string projectPath, bool forceCreate){
	//scrape off the last component of the filename for the project name
	projectPath = ofFilePath::removeTrailingSlash(projectPath);
#ifdef TARGET_WIN32
	vector<string> pathComponents = ofSplitString(projectPath, ""\\\\"");
#else
	vector<string> pathComponents = ofSplitString(projectPath, ""/"");
#endif	
	loadProject(projectPath, pathComponents[pathComponents.size()-1], forceCreate);
}

//--------------------------------------------------------------
void DurationController::loadProject(string projectPath, string projectName, bool forceCreate){    
    ofxXmlSettings projectSettings;
	string projectDataPath = ofToDataPath(projectPath+""/.durationproj"");
	if(!projectSettings.loadFile(projectDataPath)){
        if(forceCreate){
            newProject(projectPath, projectName);
        }
        else{
            ofLogError() << "" failed to load project "" << ofToDataPath(projectPath+""/.durationproj"") << endl;
        }
        return;
    }
	
	lock();
	
    timeline.removeFromThread();
    headers.clear(); //smart pointers will call destructor
    timeline.reset();

	if(audioTrack != NULL){
		delete audioTrack;
		audioTrack = NULL;
	}
    timeline.setWorkingFolder(projectPath);
	
    //LOAD ALL TRACKS
    projectSettings.pushTag(""tracks"");
    int numPages = projectSettings.getNumTags(""page"");
    for(int p = 0; p < numPages; p++){
        projectSettings.pushTag(""page"", p);
        string pageName = projectSettings.getValue(""name"", ""defaultPage"");
        if(p == 0){
            timeline.setPageName(pageName, 0);
        }
        else{
            timeline.addPage(pageName, true);
        }
		
        int numTracks = projectSettings.getNumTags(""track"");
        for(int i = 0; i < numTracks; i++){
            projectSettings.pushTag(""track"", i);
            string trackType = ofToLower(projectSettings.getValue(""type"", """"));
            string xmlFileName = projectSettings.getValue(""xmlFileName"", """");
            string trackName = projectSettings.getValue(""trackName"","""");
            string trackFilePath = ofToDataPath(projectPath + ""/"" + xmlFileName);
			
			//add the track
            ofxTLTrack* newTrack = addTrack(trackType, trackName, trackFilePath);

			//custom setup
			if(newTrack != NULL){
				ofPtr<ofxTLUIHeader> headerTrack = headers[newTrack->getName()];
				if(newTrack->getTrackType() == ""Curves"" || newTrack->getTrackType() == ""LFO""){
					headerTrack->setValueRange(ofRange(projectSettings.getValue(""min"", 0.0),
													   projectSettings.getValue(""max"", 1.0)));
				}
				else if(newTrack->getTrackType() == ""Colors""){
					ofxTLColorTrack* colors = (ofxTLColorTrack*)newTrack;
					colors->loadColorPalette(projectSettings.getValue(""palette"", timeline.getDefaultColorPalettePath()));
				}
				else if(newTrack->getTrackType() == ""Audio""){
					string clipPath = projectSettings.getValue(""clip"", """");
					if(clipPath != """"){
						audioTrack->loadSoundfile(clipPath);
					}
//					int numbins = projectSettings.getValue(""bins"", 256);
//					headerTrack->setNumberOfbins(numbins);
//					cout << ""set "" << numbins << "" after load "" << headerTrack->getNumberOfBins() << endl;
					//audioTrack->getFFTSpectrum(projectSettings.getValue(""bins"", 256));
				}

				string displayName = projectSettings.getValue(""displayName"","""");
				if(displayName != """"){
					newTrack->setDisplayName(displayName);
				}

				headerTrack->setSendOSC(projectSettings.getValue(""sendOSC"", true));
				headerTrack->setReceiveOSC(projectSettings.getValue(""receiveOSC"", true));
			}
            projectSettings.popTag(); //track
        }
        projectSettings.popTag(); //page
    }
    
    timeline.moveToThread(); //increases accuracy of bang call backs


	unlock();
	
    timeline.setCurrentPage(0);
    projectSettings.popTag(); //tracks
    
    //LOAD OTHER SETTINGS
    projectSettings.pushTag(""timelineSettings"");
    timeline.setDurationInTimecode(projectSettings.getValue(""duration"", ""00:00:00:000""));
    timeline.setCurrentTimecode(projectSettings.getValue(""playhead"", ""00:00:00:000""));
    timeline.setInPointAtTimecode(projectSettings.getValue(""inpoint"", ""00:00:00:000""));
    timeline.setOutPointAtTimecode(projectSettings.getValue(""outpoint"", ""00:00:00:000""));
	
    bool loops = projectSettings.getValue(""loop"", true);
    timeline.setLoopType(loops ? OF_LOOP_NORMAL : OF_LOOP_NONE);
	
    durationLabel->setTextString(timeline.getDurationInTimecode());
    loopToggle->setValue( loops );
    projectSettings.popTag(); //timeline settings;
	
    DurationProjectSettings newSettings;
    projectSettings.pushTag(""projectSettings"");
    
    useBPMToggle->setValue( newSettings.useBPM = projectSettings.getValue(""useBPM"", true) );
    bpmDialer->setValue( newSettings.bpm = projectSettings.getValue(""bpm"", 120.0f) );
//    snapToBPMToggle->setValue( newSettings.snapToBPM = projectSettings.getValue(""snapToBPM"", true) );
//    snapToKeysToggle->setValue( newSettings.snapToKeys = projectSettings.getValue(""snapToKeys"", true) );
    enableOSCInToggle->setValue( newSettings.oscInEnabled = projectSettings.getValue(""oscInEnabled"", true) );
	enableOSCOutToggle->setValue( newSettings.oscOutEnabled = projectSettings.getValue(""oscOutEnabled"", true) );
    oscInPortInput->setTextString( ofToString(newSettings.oscInPort = projectSettings.getValue(""oscInPort"", 12346)) );
    oscOutIPInput->setTextString( newSettings.oscIP = projectSettings.getValue(""oscIP"", ""localhost"") );
    oscOutPortInput->setTextString( ofToString(newSettings.oscOutPort = projectSettings.getValue(""oscOutPort"", 12345)) );
	newSettings.oscRate = projectSettings.getValue(""oscRate"", 30.0);
	oscFrequency = 1000 * 1/newSettings.oscRate; //frequence in millis
	
    projectSettings.popTag(); //project settings;
	
    newSettings.path = projectPath;
    newSettings.name = projectName;
    newSettings.settingsPath = ofToDataPath(newSettings.path + ""/.durationproj"");
    settings = newSettings;
	
    projectDropDown->setLabelText(projectName);
    timeline.setShowBPMGrid(newSettings.useBPM);
    timeline.enableSnapToBPM(newSettings.useBPM);
	timeline.setBPM(newSettings.bpm);
    
	oscLock.lock();
	if(settings.oscInEnabled){
		receiver.setup(settings.oscInPort);
	}
	if(settings.oscOutEnabled){
        sender.setup(settings.oscIP, settings.oscOutPort);
    }
	oscLock.unlock();
	
    ofxXmlSettings defaultSettings;
    defaultSettings.loadFile(""settings.xml"");
    defaultSettings.setValue(""lastProjectPath"", settings.path);
    defaultSettings.setValue(""lastProjectName"", settings.name);
    defaultSettings.saveFile();
	
	needsSave = false;
	sendInfoMessage();
}

//--------------------------------------------------------------
void DurationController::saveProject(){
	
	timeline.save();

    ofxXmlSettings projectSettings;
    //SAVE ALL TRACKS
    projectSettings.addTag(""tracks"");
    projectSettings.pushTag(""tracks"");
    vector<ofxTLPage*>& pages = timeline.getPages();
    for(int i = 0; i < pages.size(); i++){
        projectSettings.addTag(""page"");
        projectSettings.pushTag(""page"", i);
        projectSettings.addValue(""name"", pages[i]->getName());
        vector<ofxTLTrack*>& tracks = pages[i]->getTracks();
        for (int t = 0; t < tracks.size(); t++) {
            projectSettings.addTag(""track"");
            projectSettings.pushTag(""track"", t);
            //save track properties
            string trackType = tracks[t]->getTrackType();
            string trackName = tracks[t]->getName();
            projectSettings.addValue(""type"", trackType);
            projectSettings.addValue(""xmlFileName"", tracks[t]->getXMLFileName());
            projectSettings.addValue(""trackName"",tracks[t]->getName());
            projectSettings.addValue(""displayName"",tracks[t]->getDisplayName());
            //save custom gui props
            projectSettings.addValue(""sendOSC"", headers[trackName]->sendOSC());
			projectSettings.addValue(""receiveOSC"", headers[trackName]->receiveOSC());
            if(trackType == ""Curves"" || trackType == ""LFO""){
                ofxTLKeyframes* curves = (ofxTLKeyframes*)tracks[t];
                projectSettings.addValue(""min"", curves->getValueRange().min);
                projectSettings.addValue(""max"", curves->getValueRange().max);
				
            }
			else if(trackType == ""Colors""){
				ofxTLColorTrack* colors = (ofxTLColorTrack*)tracks[t];
				projectSettings.addValue(""palette"", colors->getPalettePath());
			}
			else if(trackType == ""Audio""){
				projectSettings.addValue(""clip"", audioTrack->getSoundfilePath());
//				int numbins = audioTrack->getFFTBinCount();
//				projectSettings.addValue(""bins"", audioTrack->getFFTBinCount());
			}
            projectSettings.popTag();
        }
        projectSettings.popTag(); //page
    }
	projectSettings.popTag(); //tracks
    
    //LOAD OTHER SETTINGS
    projectSettings.addTag(""timelineSettings"");
    projectSettings.pushTag(""timelineSettings"");
    projectSettings.addValue(""duration"", timeline.getDurationInTimecode());
    projectSettings.addValue(""playhead"", timeline.getCurrentTimecode());
    projectSettings.addValue(""inpoint"", timeline.getInPointTimecode());
    projectSettings.addValue(""outpoint"", timeline.getOutPointTimecode());
    projectSettings.addValue(""loop"", timeline.getLoopType() == OF_LOOP_NORMAL);
	projectSettings.popTag();// timelineSettings
    
    //UI SETTINGS
    projectSettings.addTag(""projectSettings"");
    projectSettings.pushTag(""projectSettings"");
    projectSettings.addValue(""useBPM"", settings.useBPM);
    projectSettings.addValue(""bpm"", settings.bpm);
    projectSettings.addValue(""snapToBPM"", settings.snapToBPM);
    projectSettings.addValue(""snapToKeys"", settings.snapToKeys);
	
    projectSettings.addValue(""oscInEnabled"", settings.oscInEnabled);
    projectSettings.addValue(""oscOutEnabled"", settings.oscOutEnabled);
    projectSettings.addValue(""oscInPort"", settings.oscInPort);
    projectSettings.addValue(""oscIP"", settings.oscIP);
    projectSettings.addValue(""oscOutPort"", settings.oscOutPort);
	projectSettings.addValue(""oscRate"", settings.oscRate);
	
//	projectSettings.addValue(""zoomViewMin"",timeline.getZoomer()->getSelectedRange().min);
//	projectSettings.addValue(""zoomViewMax"",timeline.getZoomer()->getSelectedRange().max);

	projectSettings.popTag(); //projectSettings
    projectSettings.saveFile(settings.settingsPath);
	
	needsSave = false;
}

//--------------------------------------------------------------
ofxTLUIHeader* DurationController::createHeaderForTrack(ofxTLTrack* track){
    ofxTLUIHeader* headerGui = new ofxTLUIHeader();
	headerGui->translation = &translation;
    ofxTLTrackHeader* header = timeline.getTrackHeader(track);
    headerGui->setTrackHeader(header);
    headers[track->getName()] = ofPtr<ofxTLUIHeader>( headerGui );
    return headerGui;
}

void DurationController::createTooltips(){

	//switch project
	Tooltip projectTip;
	projectTip.text = translation.translateKey(""switch project"");
	projectTip.sourceRect = *projectDropDown->getRect();
	projectTip.displayPoint = ofVec2f(projectTip.sourceRect.x, 55);
	tooltips.push_back(projectTip);
	
	//save
	Tooltip saveTip;
	saveTip.text = translation.translateKey(""save"");
	saveTip.sourceRect = *saveButton->getRect();
	saveTip.displayPoint = ofVec2f(saveTip.sourceRect.x, 55);
	tooltips.push_back(saveTip);
		
	//play/pause
	Tooltip playpauseTip;
	playpauseTip.text = translation.translateKey(""play"")+""/""+translation.translateKey(""pause""); //TODO: switch dynamically
	playpauseTip.sourceRect = *playpauseToggle->getRect();
	playpauseTip.displayPoint = ofVec2f(playpauseTip.sourceRect.x, 55);
	tooltips.push_back(playpauseTip);

	ofVec2f zone2 = playpauseTip.displayPoint;
	
	//edit duration
	Tooltip editDurationTip;
	editDurationTip.text = translation.translateKey(""edit duration"");
	editDurationTip.displayPoint = zone2;
	editDurationTip.sourceRect = *durationLabel->getRect();
	tooltips.push_back(editDurationTip);

	//current time
	Tooltip currentTimeTip;
	currentTimeTip.text = translation.translateKey(""current time"");
	currentTimeTip.displayPoint = zone2;
	currentTimeTip.sourceRect = *timeLabel->getRect();
	tooltips.push_back(currentTimeTip);
	
	//stop
	Tooltip stopTip;
	stopTip.text = translation.translateKey(""stop"");
	stopTip.sourceRect = *stopButton->getRect();
	stopTip.displayPoint = ofVec2f(stopTip.sourceRect.x, 55);
	tooltips.push_back(stopTip);
	
	//loop
	Tooltip loopTip;
	loopTip.text = translation.translateKey(""toggle loop"");
	loopTip.sourceRect = *loopToggle->getRect();
	loopTip.displayPoint = ofVec2f(loopTip.sourceRect.x, 55);
	tooltips.push_back(loopTip);

	//enable Snap to BPM
	Tooltip bpmTip;
	bpmTip.text = translation.translateKey(""snap to measures"");
	bpmTip.sourceRect = *useBPMToggle->getRect();
	bpmTip.displayPoint = ofVec2f(bpmTip.sourceRect.x, 55);
	tooltips.push_back(bpmTip);
	
	//set beats per minute
	Tooltip setBpmTip;
	setBpmTip.text = translation.translateKey(""set beats per minute"");
	setBpmTip.sourceRect = *bpmDialer->getRect();
	setBpmTip.displayPoint = ofVec2f(setBpmTip.sourceRect.x, 55);
	tooltips.push_back(setBpmTip);
	
	//enable OSC
	Tooltip oscInTip;
	oscInTip.text = translation.translateKey(""enable incoming OSC"");
	oscInTip.sourceRect = *enableOSCInToggle->getRect();
	oscInTip.displayPoint = ofVec2f(oscInTip.sourceRect.x, 55);
	tooltips.push_back(oscInTip);

	//osc In Port
	Tooltip oscInPortTip;
	oscInPortTip.text = translation.translateKey(""incoming OSC port"");
	oscInPortTip.sourceRect = *oscInPortInput->getRect();
	oscInPortTip.displayPoint = ofVec2f(oscInPortTip.sourceRect.x, 55);
	tooltips.push_back(oscInPortTip);

	//osc Out
	Tooltip oscOutTip;
	oscOutTip.text = translation.translateKey(""enable outgoing OSC"");
	oscOutTip.sourceRect = *enableOSCOutToggle->getRect();
	oscOutTip.displayPoint = ofVec2f(oscOutTip.sourceRect.x, 55);
	tooltips.push_back(oscOutTip);

	//osc Out IP
	Tooltip oscOutIPTip;
	oscOutIPTip.text = translation.translateKey(""remote IP"");
	oscOutIPTip.sourceRect = *oscOutIPInput->getRect();
	oscOutIPTip.displayPoint = ofVec2f(oscOutIPTip.sourceRect.x, 55);
	tooltips.push_back(oscOutIPTip);

	//osc Out IP
	Tooltip oscOutPortTip;
	oscOutPortTip.text = translation.translateKey(""remote port"");
	oscOutPortTip.sourceRect = *oscOutPortInput->getRect();
	oscOutPortTip.displayPoint = ofVec2f(oscOutPortTip.sourceRect.x, 55);
	tooltips.push_back(oscOutPortTip);

	
	for(int i = 0; i < tooltips.size(); i++){
		tooltips[i].debugColor = ofColor::fromHsb(ofRandom(255), ofRandom(255,200), ofRandom(255,200));		
	}	
}

void DurationController::drawTooltips(){

	ofVec2f mousepoint(ofGetMouseX(), ofGetMouseY());
	for(int i = 0; i < tooltips.size(); i++){
		if(tooltips[i].sourceRect.inside(mousepoint)){
			tooltipFont.drawString(tooltips[i].text,
								   tooltips[i].displayPoint.x,
								   tooltips[i].displayPoint.y);
		}
	}
}

void DurationController::drawTooltipDebug(){
	//draw tool tip position finder
	tooltipFont.drawString(""(""+ofToString(ofGetMouseX())+"",""+ofToString(ofGetMouseY())+"")"", ofGetMouseX(), ofGetMouseY());
	//draw tooltip debug balloons
	ofPushStyle();
	for(int i = 0; i < tooltips.size(); i++){
		ofNoFill();
		ofSetColor(tooltips[i].debugColor, 200);
		ofRect(tooltips[i].sourceRect);
		ofLine(tooltips[i].sourceRect.getMax(), tooltips[i].displayPoint);
		ofFill();
		ofSetColor(tooltips[i].debugColor, 50);
		ofRect(tooltips[i].sourceRect);
		ofSetColor(255);
		tooltipFont.drawString(tooltips[i].text, tooltips[i].sourceRect.x+5,tooltips[i].sourceRect.y+10);
	}
	ofPopStyle();
}

void DurationController::exit(ofEventArgs& e){
	lock();
	timeline.removeFromThread();
	headers.clear();
	timeline.reset();
	unlock();
	
	ofLogNotice(""DurationController"") << ""waiting for thread on exit"";
	waitForThread(true);
}
",16260,True,2935.602645297804,median
"#include ""pch.h""
/*
** $Id: lcode.c $
** Code generator for Lua
** See Copyright Notice in lua.h
*/

#define lcode_c
#define LUA_CORE

#include ""lprefix.h""


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

#include ""lua.h""

#include ""lcode.h""
#include ""ldebug.h""
#include ""ldo.h""
#include ""lgc.h""
#include ""llex.h""
#include ""lmem.h""
#include ""lobject.h""
#include ""lopcodes.h""
#include ""lparser.h""
#include ""lstring.h""
#include ""ltable.h""
#include ""lvm.h""


/* Maximum number of registers in a Lua function (must fit in 8 bits) */
#define MAXREGS		255


#define hasjumps(e)	((e)->t != (e)->f)


static int codesJ (FuncState *fs, OpCode o, int sj, int k);



/* semantic error */
l_noret luaK_semerror (LexState *ls, const char *msg) {
  ls->t.token = 0;  /* remove ""near <token>"" from final message */
  luaX_syntaxerror(ls, msg);
}


/*
** If expression is a numeric constant, fills 'v' with its value
** and returns 1. Otherwise, returns 0.
*/
static int tonumeral (const expdesc *e, TValue *v) {
  if (hasjumps(e))
    return 0;  /* not a numeral */
  switch (e->k) {
    case VKINT:
      if (v) setivalue(v, e->u.ival);
      return 1;
    case VKFLT:
      if (v) setfltvalue(v, e->u.nval);
      return 1;
    default: return 0;
  }
}


/*
** Get the constant value from a constant expression
*/
static TValue *const2val (FuncState *fs, const expdesc *e) {
  lua_assert(e->k == VCONST);
  return &fs->ls->dyd->actvar.arr[e->u.info].k;
}


/*
** If expression is a constant, fills 'v' with its value
** and returns 1. Otherwise, returns 0.
*/
int luaK_exp2const (FuncState *fs, const expdesc *e, TValue *v) {
  if (hasjumps(e))
    return 0;  /* not a constant */
  switch (e->k) {
    case VFALSE:
      setbfvalue(v);
      return 1;
    case VTRUE:
      setbtvalue(v);
      return 1;
    case VNIL:
      setnilvalue(v);
      return 1;
    case VKSTR: {
      setsvalue(fs->ls->L, v, e->u.strval);
      return 1;
    }
    case VCONST: {
      setobj(fs->ls->L, v, const2val(fs, e));
      return 1;
    }
    default: return tonumeral(e, v);
  }
}


/*
** Return the previous instruction of the current code. If there
** may be a jump target between the current instruction and the
** previous one, return an invalid instruction (to avoid wrong
** optimizations).
*/
static Instruction *previousinstruction (FuncState *fs) {
  static const Instruction invalidinstruction = ~(Instruction)0;
  if (fs->pc > fs->lasttarget)
    return &fs->f->code[fs->pc - 1];  /* previous instruction */
  else
    return cast(Instruction*, &invalidinstruction);
}


/*
** Create a OP_LOADNIL instruction, but try to optimize: if the previous
** instruction is also OP_LOADNIL and ranges are compatible, adjust
** range of previous instruction instead of emitting a new one. (For
** instance, 'local a; local b' will generate a single opcode.)
*/
void luaK_nil (FuncState *fs, int from, int n) {
  int l = from + n - 1;  /* last register to set nil */
  Instruction *previous = previousinstruction(fs);
  if (GET_OPCODE(*previous) == OP_LOADNIL) {  /* previous is LOADNIL? */
    int pfrom = GETARG_A(*previous);  /* get previous range */
    int pl = pfrom + GETARG_B(*previous);
    if ((pfrom <= from && from <= pl + 1) ||
        (from <= pfrom && pfrom <= l + 1)) {  /* can connect both? */
      if (pfrom < from) from = pfrom;  /* from = min(from, pfrom) */
      if (pl > l) l = pl;  /* l = max(l, pl) */
      SETARG_A(*previous, from);
      SETARG_B(*previous, l - from);
      return;
    }  /* else go through */
  }
  luaK_codeABC(fs, OP_LOADNIL, from, n - 1, 0);  /* else no optimization */
}


/*
** Gets the destination address of a jump instruction. Used to traverse
** a list of jumps.
*/
static int getjump (FuncState *fs, int pc) {
  int offset = GETARG_sJ(fs->f->code[pc]);
  if (offset == NO_JUMP)  /* point to itself represents end of list */
    return NO_JUMP;  /* end of list */
  else
    return (pc+1)+offset;  /* turn offset into absolute position */
}


/*
** Fix jump instruction at position 'pc' to jump to 'dest'.
** (Jump addresses are relative in Lua)
*/
static void fixjump (FuncState *fs, int pc, int dest) {
  Instruction *jmp = &fs->f->code[pc];
  int offset = dest - (pc + 1);
  lua_assert(dest != NO_JUMP);
  if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ))
    luaX_syntaxerror(fs->ls, ""control structure too long"");
  lua_assert(GET_OPCODE(*jmp) == OP_JMP);
  SETARG_sJ(*jmp, offset);
}


/*
** Concatenate jump-list 'l2' into jump-list 'l1'
*/
void luaK_concat (FuncState *fs, int *l1, int l2) {
  if (l2 == NO_JUMP) return;  /* nothing to concatenate? */
  else if (*l1 == NO_JUMP)  /* no original list? */
    *l1 = l2;  /* 'l1' points to 'l2' */
  else {
    int list = *l1;
    int next;
    while ((next = getjump(fs, list)) != NO_JUMP)  /* find last element */
      list = next;
    fixjump(fs, list, l2);  /* last element links to 'l2' */
  }
}


/*
** Create a jump instruction and return its position, so its destination
** can be fixed later (with 'fixjump').
*/
int luaK_jump (FuncState *fs) {
  return codesJ(fs, OP_JMP, NO_JUMP, 0);
}


/*
** Code a 'return' instruction
*/
void luaK_ret (FuncState *fs, int first, int nret) {
  OpCode op;
  switch (nret) {
    case 0: op = OP_RETURN0; break;
    case 1: op = OP_RETURN1; break;
    default: op = OP_RETURN; break;
  }
  luaK_codeABC(fs, op, first, nret + 1, 0);
}


/*
** Code a ""conditional jump"", that is, a test or comparison opcode
** followed by a jump. Return jump position.
*/
static int condjump (FuncState *fs, OpCode op, int A, int B, int C, int k) {
  luaK_codeABCk(fs, op, A, B, C, k);
  return luaK_jump(fs);
}


/*
** returns current 'pc' and marks it as a jump target (to avoid wrong
** optimizations with consecutive instructions not in the same basic block).
*/
int luaK_getlabel (FuncState *fs) {
  fs->lasttarget = fs->pc;
  return fs->pc;
}


/*
** Returns the position of the instruction ""controlling"" a given
** jump (that is, its condition), or the jump itself if it is
** unconditional.
*/
static Instruction *getjumpcontrol (FuncState *fs, int pc) {
  Instruction *pi = &fs->f->code[pc];
  if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1))))
    return pi-1;
  else
    return pi;
}


/*
** Patch destination register for a TESTSET instruction.
** If instruction in position 'node' is not a TESTSET, return 0 (""fails"").
** Otherwise, if 'reg' is not 'NO_REG', set it as the destination
** register. Otherwise, change instruction to a simple 'TEST' (produces
** no register value)
*/
static int patchtestreg (FuncState *fs, int node, int reg) {
  Instruction *i = getjumpcontrol(fs, node);
  if (GET_OPCODE(*i) != OP_TESTSET)
    return 0;  /* cannot patch other instructions */
  if (reg != NO_REG && reg != GETARG_B(*i))
    SETARG_A(*i, reg);
  else {
     /* no register to put value or register already has the value;
        change instruction to simple test */
    *i = CREATE_ABCk(OP_TEST, GETARG_B(*i), 0, 0, GETARG_k(*i));
  }
  return 1;
}


/*
** Traverse a list of tests ensuring no one produces a value
*/
static void removevalues (FuncState *fs, int list) {
  for (; list != NO_JUMP; list = getjump(fs, list))
      patchtestreg(fs, list, NO_REG);
}


/*
** Traverse a list of tests, patching their destination address and
** registers: tests producing values jump to 'vtarget' (and put their
** values in 'reg'), other tests jump to 'dtarget'.
*/
static void patchlistaux (FuncState *fs, int list, int vtarget, int reg,
                          int dtarget) {
  while (list != NO_JUMP) {
    int next = getjump(fs, list);
    if (patchtestreg(fs, list, reg))
      fixjump(fs, list, vtarget);
    else
      fixjump(fs, list, dtarget);  /* jump to default target */
    list = next;
  }
}


/*
** Path all jumps in 'list' to jump to 'target'.
** (The assert means that we cannot fix a jump to a forward address
** because we only know addresses once code is generated.)
*/
void luaK_patchlist (FuncState *fs, int list, int target) {
  lua_assert(target <= fs->pc);
  patchlistaux(fs, list, target, NO_REG, target);
}


void luaK_patchtohere (FuncState *fs, int list) {
  int hr = luaK_getlabel(fs);  /* mark ""here"" as a jump target */
  luaK_patchlist(fs, list, hr);
}


/* limit for difference between lines in relative line info. */
#define LIMLINEDIFF	0x80


/*
** Save line info for a new instruction. If difference from last line
** does not fit in a byte, of after that many instructions, save a new
** absolute line info; (in that case, the special value 'ABSLINEINFO'
** in 'lineinfo' signals the existence of this absolute information.)
** Otherwise, store the difference from last line in 'lineinfo'.
*/
static void savelineinfo (FuncState *fs, Proto *f, int line) {
  int linedif = line - fs->previousline;
  int pc = fs->pc - 1;  /* last instruction coded */
  if (abs(linedif) >= LIMLINEDIFF || fs->iwthabs++ >= MAXIWTHABS) {
    luaM_growvector(fs->ls->L, f->abslineinfo, fs->nabslineinfo,
                    f->sizeabslineinfo, AbsLineInfo, MAX_INT, ""lines"");
    f->abslineinfo[fs->nabslineinfo].pc = pc;
    f->abslineinfo[fs->nabslineinfo++].line = line;
    linedif = ABSLINEINFO;  /* signal that there is absolute information */
    fs->iwthabs = 1;  /* restart counter */
  }
  luaM_growvector(fs->ls->L, f->lineinfo, pc, f->sizelineinfo, ls_byte,
                  MAX_INT, ""opcodes"");
  f->lineinfo[pc] = linedif;
  fs->previousline = line;  /* last line saved */
}


/*
** Remove line information from the last instruction.
** If line information for that instruction is absolute, set 'iwthabs'
** above its max to force the new (replacing) instruction to have
** absolute line info, too.
*/
static void removelastlineinfo (FuncState *fs) {
  Proto *f = fs->f;
  int pc = fs->pc - 1;  /* last instruction coded */
  if (f->lineinfo[pc] != ABSLINEINFO) {  /* relative line info? */
    fs->previousline -= f->lineinfo[pc];  /* correct last line saved */
    fs->iwthabs--;  /* undo previous increment */
  }
  else {  /* absolute line information */
    lua_assert(f->abslineinfo[fs->nabslineinfo - 1].pc == pc);
    fs->nabslineinfo--;  /* remove it */
    fs->iwthabs = MAXIWTHABS + 1;  /* force next line info to be absolute */
  }
}


/*
** Remove the last instruction created, correcting line information
** accordingly.
*/
static void removelastinstruction (FuncState *fs) {
  removelastlineinfo(fs);
  fs->pc--;
}


/*
** Emit instruction 'i', checking for array sizes and saving also its
** line information. Return 'i' position.
*/
int luaK_code (FuncState *fs, Instruction i) {
  Proto *f = fs->f;
  /* put new instruction in code array */
  luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction,
                  MAX_INT, ""opcodes"");
  f->code[fs->pc++] = i;
  savelineinfo(fs, f, fs->ls->lastline);
  return fs->pc - 1;  /* index of new instruction */
}


/*
** Format and emit an 'iABC' instruction. (Assertions check consistency
** of parameters versus opcode.)
*/
int luaK_codeABCk (FuncState *fs, OpCode o, int a, int b, int c, int k) {
  lua_assert(getOpMode(o) == iABC);
  lua_assert(a <= MAXARG_A && b <= MAXARG_B &&
             c <= MAXARG_C && (k & ~1) == 0);
  return luaK_code(fs, CREATE_ABCk(o, a, b, c, k));
}


/*
** Format and emit an 'iABx' instruction.
*/
int luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc) {
  lua_assert(getOpMode(o) == iABx);
  lua_assert(a <= MAXARG_A && bc <= MAXARG_Bx);
  return luaK_code(fs, CREATE_ABx(o, a, bc));
}


/*
** Format and emit an 'iAsBx' instruction.
*/
int luaK_codeAsBx (FuncState *fs, OpCode o, int a, int bc) {
  unsigned int b = bc + OFFSET_sBx;
  lua_assert(getOpMode(o) == iAsBx);
  lua_assert(a <= MAXARG_A && b <= MAXARG_Bx);
  return luaK_code(fs, CREATE_ABx(o, a, b));
}


/*
** Format and emit an 'isJ' instruction.
*/
static int codesJ (FuncState *fs, OpCode o, int sj, int k) {
  unsigned int j = sj + OFFSET_sJ;
  lua_assert(getOpMode(o) == isJ);
  lua_assert(j <= MAXARG_sJ && (k & ~1) == 0);
  return luaK_code(fs, CREATE_sJ(o, j, k));
}


/*
** Emit an ""extra argument"" instruction (format 'iAx')
*/
static int codeextraarg (FuncState *fs, int a) {
  lua_assert(a <= MAXARG_Ax);
  return luaK_code(fs, CREATE_Ax(OP_EXTRAARG, a));
}


/*
** Emit a ""load constant"" instruction, using either 'OP_LOADK'
** (if constant index 'k' fits in 18 bits) or an 'OP_LOADKX'
** instruction with ""extra argument"".
*/
static int luaK_codek (FuncState *fs, int reg, int k) {
  if (k <= MAXARG_Bx)
    return luaK_codeABx(fs, OP_LOADK, reg, k);
  else {
    int p = luaK_codeABx(fs, OP_LOADKX, reg, 0);
    codeextraarg(fs, k);
    return p;
  }
}


/*
** Check register-stack level, keeping track of its maximum size
** in field 'maxstacksize'
*/
void luaK_checkstack (FuncState *fs, int n) {
  int newstack = fs->freereg + n;
  if (newstack > fs->f->maxstacksize) {
    if (newstack >= MAXREGS)
      luaX_syntaxerror(fs->ls,
        ""function or expression needs too many registers"");
    fs->f->maxstacksize = cast_byte(newstack);
  }
}


/*
** Reserve 'n' registers in register stack
*/
void luaK_reserveregs (FuncState *fs, int n) {
  luaK_checkstack(fs, n);
  fs->freereg += n;
}


/*
** Free register 'reg', if it is neither a constant index nor
** a local variable.
)
*/
static void freereg (FuncState *fs, int reg) {
  if (reg >= luaY_nvarstack(fs)) {
    fs->freereg--;
    lua_assert(reg == fs->freereg);
  }
}


/*
** Free two registers in proper order
*/
static void freeregs (FuncState *fs, int r1, int r2) {
  if (r1 > r2) {
    freereg(fs, r1);
    freereg(fs, r2);
  }
  else {
    freereg(fs, r2);
    freereg(fs, r1);
  }
}


/*
** Free register used by expression 'e' (if any)
*/
static void freeexp (FuncState *fs, expdesc *e) {
  if (e->k == VNONRELOC)
    freereg(fs, e->u.info);
}


/*
** Free registers used by expressions 'e1' and 'e2' (if any) in proper
** order.
*/
static void freeexps (FuncState *fs, expdesc *e1, expdesc *e2) {
  int r1 = (e1->k == VNONRELOC) ? e1->u.info : -1;
  int r2 = (e2->k == VNONRELOC) ? e2->u.info : -1;
  freeregs(fs, r1, r2);
}


/*
** Add constant 'v' to prototype's list of constants (field 'k').
** Use scanner's table to cache position of constants in constant list
** and try to reuse constants. Because some values should not be used
** as keys (nil cannot be a key, integer keys can collapse with float
** keys), the caller must provide a useful 'key' for indexing the cache.
** Note that all functions share the same table, so entering or exiting
** a function can make some indices wrong.
*/
static int addk (FuncState *fs, TValue *key, TValue *v) {
  TValue val;
  lua_State *L = fs->ls->L;
  Proto *f = fs->f;
  const TValue *idx = luaH_get(fs->ls->h, key);  /* query scanner table */
  int k, oldsize;
  if (ttisinteger(idx)) {  /* is there an index there? */
    k = cast_int(ivalue(idx));
    /* correct value? (warning: must distinguish floats from integers!) */
    if (k < fs->nk && ttypetag(&f->k[k]) == ttypetag(v) &&
                      luaV_rawequalobj(&f->k[k], v))
      return k;  /* reuse index */
  }
  /* constant not found; create a new entry */
  oldsize = f->sizek;
  k = fs->nk;
  /* numerical value does not need GC barrier;
     table has no metatable, so it does not need to invalidate cache */
  setivalue(&val, k);
  luaH_finishset(L, fs->ls->h, key, idx, &val);
  luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, ""constants"");
  while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
  setobj(L, &f->k[k], v);
  fs->nk++;
  luaC_barrier(L, f, v);
  return k;
}


/*
** Add a string to list of constants and return its index.
*/
static int stringK (FuncState *fs, TString *s) {
  TValue o;
  setsvalue(fs->ls->L, &o, s);
  return addk(fs, &o, &o);  /* use string itself as key */
}


/*
** Add an integer to list of constants and return its index.
** Integers use userdata as keys to avoid collision with floats with
** same value; conversion to 'void*' is used only for hashing, so there
** are no ""precision"" problems.
*/
static int luaK_intK (FuncState *fs, lua_Integer n) {
  TValue k, o;
  setpvalue(&k, cast_voidp(cast_sizet(n)));
  setivalue(&o, n);
  return addk(fs, &k, &o);
}

/*
** Add a float to list of constants and return its index.
*/
static int luaK_numberK (FuncState *fs, lua_Number r) {
  TValue o;
  setfltvalue(&o, r);
  return addk(fs, &o, &o);  /* use number itself as key */
}


/*
** Add a false to list of constants and return its index.
*/
static int boolF (FuncState *fs) {
  TValue o;
  setbfvalue(&o);
  return addk(fs, &o, &o);  /* use boolean itself as key */
}


/*
** Add a true to list of constants and return its index.
*/
static int boolT (FuncState *fs) {
  TValue o;
  setbtvalue(&o);
  return addk(fs, &o, &o);  /* use boolean itself as key */
}


/*
** Add nil to list of constants and return its index.
*/
static int nilK (FuncState *fs) {
  TValue k, v;
  setnilvalue(&v);
  /* cannot use nil as key; instead use table itself to represent nil */
  sethvalue(fs->ls->L, &k, fs->ls->h);
  return addk(fs, &k, &v);
}


/*
** Check whether 'i' can be stored in an 'sC' operand. Equivalent to
** (0 <= int2sC(i) && int2sC(i) <= MAXARG_C) but without risk of
** overflows in the hidden addition inside 'int2sC'.
*/
static int fitsC (lua_Integer i) {
  return (l_castS2U(i) + OFFSET_sC <= cast_uint(MAXARG_C));
}


/*
** Check whether 'i' can be stored in an 'sBx' operand.
*/
static int fitsBx (lua_Integer i) {
  return (-OFFSET_sBx <= i && i <= MAXARG_Bx - OFFSET_sBx);
}


void luaK_int (FuncState *fs, int reg, lua_Integer i) {
  if (fitsBx(i))
    luaK_codeAsBx(fs, OP_LOADI, reg, cast_int(i));
  else
    luaK_codek(fs, reg, luaK_intK(fs, i));
}


static void luaK_float (FuncState *fs, int reg, lua_Number f) {
  lua_Integer fi;
  if (luaV_flttointeger(f, &fi, F2Ieq) && fitsBx(fi))
    luaK_codeAsBx(fs, OP_LOADF, reg, cast_int(fi));
  else
    luaK_codek(fs, reg, luaK_numberK(fs, f));
}


/*
** Convert a constant in 'v' into an expression description 'e'
*/
static void const2exp (TValue *v, expdesc *e) {
  switch (ttypetag(v)) {
    case LUA_VNUMINT:
      e->k = VKINT; e->u.ival = ivalue(v);
      break;
    case LUA_VNUMFLT:
      e->k = VKFLT; e->u.nval = fltvalue(v);
      break;
    case LUA_VFALSE:
      e->k = VFALSE;
      break;
    case LUA_VTRUE:
      e->k = VTRUE;
      break;
    case LUA_VNIL:
      e->k = VNIL;
      break;
    case LUA_VSHRSTR:  case LUA_VLNGSTR:
      e->k = VKSTR; e->u.strval = tsvalue(v);
      break;
    default: lua_assert(0);
  }
}


/*
** Fix an expression to return the number of results 'nresults'.
** 'e' must be a multi-ret expression (function call or vararg).
*/
void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {
  Instruction *pc = &getinstruction(fs, e);
  if (e->k == VCALL)  /* expression is an open function call? */
    SETARG_C(*pc, nresults + 1);
  else {
    lua_assert(e->k == VVARARG);
    SETARG_C(*pc, nresults + 1);
    SETARG_A(*pc, fs->freereg);
    luaK_reserveregs(fs, 1);
  }
}


/*
** Convert a VKSTR to a VK
*/
static void str2K (FuncState *fs, expdesc *e) {
  lua_assert(e->k == VKSTR);
  e->u.info = stringK(fs, e->u.strval);
  e->k = VK;
}


/*
** Fix an expression to return one result.
** If expression is not a multi-ret expression (function call or
** vararg), it already returns one result, so nothing needs to be done.
** Function calls become VNONRELOC expressions (as its result comes
** fixed in the base register of the call), while vararg expressions
** become VRELOC (as OP_VARARG puts its results where it wants).
** (Calls are created returning one result, so that does not need
** to be fixed.)
*/
void luaK_setoneret (FuncState *fs, expdesc *e) {
  if (e->k == VCALL) {  /* expression is an open function call? */
    /* already returns 1 value */
    lua_assert(GETARG_C(getinstruction(fs, e)) == 2);
    e->k = VNONRELOC;  /* result has fixed position */
    e->u.info = GETARG_A(getinstruction(fs, e));
  }
  else if (e->k == VVARARG) {
    SETARG_C(getinstruction(fs, e), 2);
    e->k = VRELOC;  /* can relocate its simple result */
  }
}


/*
** Ensure that expression 'e' is not a variable (nor a <const>).
** (Expression still may have jump lists.)
*/
void luaK_dischargevars (FuncState *fs, expdesc *e) {
  switch (e->k) {
    case VCONST: {
      const2exp(const2val(fs, e), e);
      break;
    }
    case VLOCAL: {  /* already in a register */
      e->u.info = e->u.var.ridx;
      e->k = VNONRELOC;  /* becomes a non-relocatable value */
      break;
    }
    case VUPVAL: {  /* move value to some (pending) register */
      e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0);
      e->k = VRELOC;
      break;
    }
    case VINDEXUP: {
      e->u.info = luaK_codeABC(fs, OP_GETTABUP, 0, e->u.ind.t, e->u.ind.idx);
      e->k = VRELOC;
      break;
    }
    case VINDEXI: {
      freereg(fs, e->u.ind.t);
      e->u.info = luaK_codeABC(fs, OP_GETI, 0, e->u.ind.t, e->u.ind.idx);
      e->k = VRELOC;
      break;
    }
    case VINDEXSTR: {
      freereg(fs, e->u.ind.t);
      e->u.info = luaK_codeABC(fs, OP_GETFIELD, 0, e->u.ind.t, e->u.ind.idx);
      e->k = VRELOC;
      break;
    }
    case VINDEXED: {
      freeregs(fs, e->u.ind.t, e->u.ind.idx);
      e->u.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.ind.t, e->u.ind.idx);
      e->k = VRELOC;
      break;
    }
    case VVARARG: case VCALL: {
      luaK_setoneret(fs, e);
      break;
    }
    default: break;  /* there is one value available (somewhere) */
  }
}


/*
** Ensure expression value is in register 'reg', making 'e' a
** non-relocatable expression.
** (Expression still may have jump lists.)
*/
static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VNIL: {
      luaK_nil(fs, reg, 1);
      break;
    }
    case VFALSE: {
      luaK_codeABC(fs, OP_LOADFALSE, reg, 0, 0);
      break;
    }
    case VTRUE: {
      luaK_codeABC(fs, OP_LOADTRUE, reg, 0, 0);
      break;
    }
    case VKSTR: {
      str2K(fs, e);
    }  /* FALLTHROUGH */
    case VK: {
      luaK_codek(fs, reg, e->u.info);
      break;
    }
    case VKFLT: {
      luaK_float(fs, reg, e->u.nval);
      break;
    }
    case VKINT: {
      luaK_int(fs, reg, e->u.ival);
      break;
    }
    case VRELOC: {
      Instruction *pc = &getinstruction(fs, e);
      SETARG_A(*pc, reg);  /* instruction will put result in 'reg' */
      break;
    }
    case VNONRELOC: {
      if (reg != e->u.info)
        luaK_codeABC(fs, OP_MOVE, reg, e->u.info, 0);
      break;
    }
    default: {
      lua_assert(e->k == VJMP);
      return;  /* nothing to do... */
    }
  }
  e->u.info = reg;
  e->k = VNONRELOC;
}


/*
** Ensure expression value is in a register, making 'e' a
** non-relocatable expression.
** (Expression still may have jump lists.)
*/
static void discharge2anyreg (FuncState *fs, expdesc *e) {
  if (e->k != VNONRELOC) {  /* no fixed register yet? */
    luaK_reserveregs(fs, 1);  /* get a register */
    discharge2reg(fs, e, fs->freereg-1);  /* put value there */
  }
}


static int code_loadbool (FuncState *fs, int A, OpCode op) {
  luaK_getlabel(fs);  /* those instructions may be jump targets */
  return luaK_codeABC(fs, op, A, 0, 0);
}


/*
** check whether list has any jump that do not produce a value
** or produce an inverted value
*/
static int need_value (FuncState *fs, int list) {
  for (; list != NO_JUMP; list = getjump(fs, list)) {
    Instruction i = *getjumpcontrol(fs, list);
    if (GET_OPCODE(i) != OP_TESTSET) return 1;
  }
  return 0;  /* not found */
}


/*
** Ensures final expression result (which includes results from its
** jump lists) is in register 'reg'.
** If expression has jumps, need to patch these jumps either to
** its final position or to ""load"" instructions (for those tests
** that do not produce values).
*/
static void exp2reg (FuncState *fs, expdesc *e, int reg) {
  discharge2reg(fs, e, reg);
  if (e->k == VJMP)  /* expression itself is a test? */
    luaK_concat(fs, &e->t, e->u.info);  /* put this jump in 't' list */
  if (hasjumps(e)) {
    int final;  /* position after whole expression */
    int p_f = NO_JUMP;  /* position of an eventual LOAD false */
    int p_t = NO_JUMP;  /* position of an eventual LOAD true */
    if (need_value(fs, e->t) || need_value(fs, e->f)) {
      int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);
      p_f = code_loadbool(fs, reg, OP_LFALSESKIP);  /* skip next inst. */
      p_t = code_loadbool(fs, reg, OP_LOADTRUE);
      /* jump around these booleans if 'e' is not a test */
      luaK_patchtohere(fs, fj);
    }
    final = luaK_getlabel(fs);
    patchlistaux(fs, e->f, final, reg, p_f);
    patchlistaux(fs, e->t, final, reg, p_t);
  }
  e->f = e->t = NO_JUMP;
  e->u.info = reg;
  e->k = VNONRELOC;
}


/*
** Ensures final expression result is in next available register.
*/
void luaK_exp2nextreg (FuncState *fs, expdesc *e) {
  luaK_dischargevars(fs, e);
  freeexp(fs, e);
  luaK_reserveregs(fs, 1);
  exp2reg(fs, e, fs->freereg - 1);
}


/*
** Ensures final expression result is in some (any) register
** and return that register.
*/
int luaK_exp2anyreg (FuncState *fs, expdesc *e) {
  luaK_dischargevars(fs, e);
  if (e->k == VNONRELOC) {  /* expression already has a register? */
    if (!hasjumps(e))  /* no jumps? */
      return e->u.info;  /* result is already in a register */
    if (e->u.info >= luaY_nvarstack(fs)) {  /* reg. is not a local? */
      exp2reg(fs, e, e->u.info);  /* put final result in it */
      return e->u.info;
    }
    /* else expression has jumps and cannot change its register
       to hold the jump values, because it is a local variable.
       Go through to the default case. */
  }
  luaK_exp2nextreg(fs, e);  /* default: use next available register */
  return e->u.info;
}


/*
** Ensures final expression result is either in a register
** or in an upvalue.
*/
void luaK_exp2anyregup (FuncState *fs, expdesc *e) {
  if (e->k != VUPVAL || hasjumps(e))
    luaK_exp2anyreg(fs, e);
}


/*
** Ensures final expression result is either in a register
** or it is a constant.
*/
void luaK_exp2val (FuncState *fs, expdesc *e) {
  if (hasjumps(e))
    luaK_exp2anyreg(fs, e);
  else
    luaK_dischargevars(fs, e);
}


/*
** Try to make 'e' a K expression with an index in the range of R/K
** indices. Return true iff succeeded.
*/
static int luaK_exp2K (FuncState *fs, expdesc *e) {
  if (!hasjumps(e)) {
    int info;
    switch (e->k) {  /* move constants to 'k' */
      case VTRUE: info = boolT(fs); break;
      case VFALSE: info = boolF(fs); break;
      case VNIL: info = nilK(fs); break;
      case VKINT: info = luaK_intK(fs, e->u.ival); break;
      case VKFLT: info = luaK_numberK(fs, e->u.nval); break;
      case VKSTR: info = stringK(fs, e->u.strval); break;
      case VK: info = e->u.info; break;
      default: return 0;  /* not a constant */
    }
    if (info <= MAXINDEXRK) {  /* does constant fit in 'argC'? */
      e->k = VK;  /* make expression a 'K' expression */
      e->u.info = info;
      return 1;
    }
  }
  /* else, expression doesn't fit; leave it unchanged */
  return 0;
}


/*
** Ensures final expression result is in a valid R/K index
** (that is, it is either in a register or in 'k' with an index
** in the range of R/K indices).
** Returns 1 iff expression is K.
*/
int luaK_exp2RK (FuncState *fs, expdesc *e) {
  if (luaK_exp2K(fs, e))
    return 1;
  else {  /* not a constant in the right range: put it in a register */
    luaK_exp2anyreg(fs, e);
    return 0;
  }
}


static void codeABRK (FuncState *fs, OpCode o, int a, int b,
                      expdesc *ec) {
  int k = luaK_exp2RK(fs, ec);
  luaK_codeABCk(fs, o, a, b, ec->u.info, k);
}


/*
** Generate code to store result of expression 'ex' into variable 'var'.
*/
void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {
  switch (var->k) {
    case VLOCAL: {
      freeexp(fs, ex);
      exp2reg(fs, ex, var->u.var.ridx);  /* compute 'ex' into proper place */
      return;
    }
    case VUPVAL: {
      int e = luaK_exp2anyreg(fs, ex);
      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.info, 0);
      break;
    }
    case VINDEXUP: {
      codeABRK(fs, OP_SETTABUP, var->u.ind.t, var->u.ind.idx, ex);
      break;
    }
    case VINDEXI: {
      codeABRK(fs, OP_SETI, var->u.ind.t, var->u.ind.idx, ex);
      break;
    }
    case VINDEXSTR: {
      codeABRK(fs, OP_SETFIELD, var->u.ind.t, var->u.ind.idx, ex);
      break;
    }
    case VINDEXED: {
      codeABRK(fs, OP_SETTABLE, var->u.ind.t, var->u.ind.idx, ex);
      break;
    }
    default: lua_assert(0);  /* invalid var kind to store */
  }
  freeexp(fs, ex);
}


/*
** Emit SELF instruction (convert expression 'e' into 'e:key(e,').
*/
void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
  int ereg;
  luaK_exp2anyreg(fs, e);
  ereg = e->u.info;  /* register where 'e' was placed */
  freeexp(fs, e);
  e->u.info = fs->freereg;  /* base register for op_self */
  e->k = VNONRELOC;  /* self expression has a fixed register */
  luaK_reserveregs(fs, 2);  /* function and 'self' produced by op_self */
  codeABRK(fs, OP_SELF, e->u.info, ereg, key);
  freeexp(fs, key);
}


/*
** Negate condition 'e' (where 'e' is a comparison).
*/
static void negatecondition (FuncState *fs, expdesc *e) {
  Instruction *pc = getjumpcontrol(fs, e->u.info);
  lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&
                                           GET_OPCODE(*pc) != OP_TEST);
  SETARG_k(*pc, (GETARG_k(*pc) ^ 1));
}


/*
** Emit instruction to jump if 'e' is 'cond' (that is, if 'cond'
** is true, code will jump if 'e' is true.) Return jump position.
** Optimize when 'e' is 'not' something, inverting the condition
** and removing the 'not'.
*/
static int jumponcond (FuncState *fs, expdesc *e, int cond) {
  if (e->k == VRELOC) {
    Instruction ie = getinstruction(fs, e);
    if (GET_OPCODE(ie) == OP_NOT) {
      removelastinstruction(fs);  /* remove previous OP_NOT */
      return condjump(fs, OP_TEST, GETARG_B(ie), 0, 0, !cond);
    }
    /* else go through */
  }
  discharge2anyreg(fs, e);
  freeexp(fs, e);
  return condjump(fs, OP_TESTSET, NO_REG, e->u.info, 0, cond);
}


/*
** Emit code to go through if 'e' is true, jump otherwise.
*/
void luaK_goiftrue (FuncState *fs, expdesc *e) {
  int pc;  /* pc of new jump */
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VJMP: {  /* condition? */
      negatecondition(fs, e);  /* jump when it is false */
      pc = e->u.info;  /* save jump position */
      break;
    }
    case VK: case VKFLT: case VKINT: case VKSTR: case VTRUE: {
      pc = NO_JUMP;  /* always true; do nothing */
      break;
    }
    default: {
      pc = jumponcond(fs, e, 0);  /* jump when false */
      break;
    }
  }
  luaK_concat(fs, &e->f, pc);  /* insert new jump in false list */
  luaK_patchtohere(fs, e->t);  /* true list jumps to here (to go through) */
  e->t = NO_JUMP;
}


/*
** Emit code to go through if 'e' is false, jump otherwise.
*/
void luaK_goiffalse (FuncState *fs, expdesc *e) {
  int pc;  /* pc of new jump */
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VJMP: {
      pc = e->u.info;  /* already jump if true */
      break;
    }
    case VNIL: case VFALSE: {
      pc = NO_JUMP;  /* always false; do nothing */
      break;
    }
    default: {
      pc = jumponcond(fs, e, 1);  /* jump if true */
      break;
    }
  }
  luaK_concat(fs, &e->t, pc);  /* insert new jump in 't' list */
  luaK_patchtohere(fs, e->f);  /* false list jumps to here (to go through) */
  e->f = NO_JUMP;
}


/*
** Code 'not e', doing constant folding.
*/
static void codenot (FuncState *fs, expdesc *e) {
  switch (e->k) {
    case VNIL: case VFALSE: {
      e->k = VTRUE;  /* true == not nil == not false */
      break;
    }
    case VK: case VKFLT: case VKINT: case VKSTR: case VTRUE: {
      e->k = VFALSE;  /* false == not ""x"" == not 0.5 == not 1 == not true */
      break;
    }
    case VJMP: {
      negatecondition(fs, e);
      break;
    }
    case VRELOC:
    case VNONRELOC: {
      discharge2anyreg(fs, e);
      freeexp(fs, e);
      e->u.info = luaK_codeABC(fs, OP_NOT, 0, e->u.info, 0);
      e->k = VRELOC;
      break;
    }
    default: lua_assert(0);  /* cannot happen */
  }
  /* interchange true and false lists */
  { int temp = e->f; e->f = e->t; e->t = temp; }
  removevalues(fs, e->f);  /* values are useless when negated */
  removevalues(fs, e->t);
}


/*
** Check whether expression 'e' is a small literal string
*/
static int isKstr (FuncState *fs, expdesc *e) {
  return (e->k == VK && !hasjumps(e) && e->u.info <= MAXARG_B &&
          ttisshrstring(&fs->f->k[e->u.info]));
}

/*
** Check whether expression 'e' is a literal integer.
*/
int luaK_isKint (expdesc *e) {
  return (e->k == VKINT && !hasjumps(e));
}


/*
** Check whether expression 'e' is a literal integer in
** proper range to fit in register C
*/
static int isCint (expdesc *e) {
  return luaK_isKint(e) && (l_castS2U(e->u.ival) <= l_castS2U(MAXARG_C));
}


/*
** Check whether expression 'e' is a literal integer in
** proper range to fit in register sC
*/
static int isSCint (expdesc *e) {
  return luaK_isKint(e) && fitsC(e->u.ival);
}


/*
** Check whether expression 'e' is a literal integer or float in
** proper range to fit in a register (sB or sC).
*/
static int isSCnumber (expdesc *e, int *pi, int *isfloat) {
  lua_Integer i;
  if (e->k == VKINT)
    i = e->u.ival;
  else if (e->k == VKFLT && luaV_flttointeger(e->u.nval, &i, F2Ieq))
    *isfloat = 1;
  else
    return 0;  /* not a number */
  if (!hasjumps(e) && fitsC(i)) {
    *pi = int2sC(cast_int(i));
    return 1;
  }
  else
    return 0;
}


/*
** Create expression 't[k]'. 't' must have its final result already in a
** register or upvalue. Upvalues can only be indexed by literal strings.
** Keys can be literal strings in the constant table or arbitrary
** values in registers.
*/
void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
  if (k->k == VKSTR)
    str2K(fs, k);
  lua_assert(!hasjumps(t) &&
             (t->k == VLOCAL || t->k == VNONRELOC || t->k == VUPVAL));
  if (t->k == VUPVAL && !isKstr(fs, k))  /* upvalue indexed by non 'Kstr'? */
    luaK_exp2anyreg(fs, t);  /* put it in a register */
  if (t->k == VUPVAL) {
    t->u.ind.t = t->u.info;  /* upvalue index */
    t->u.ind.idx = k->u.info;  /* literal string */
    t->k = VINDEXUP;
  }
  else {
    /* register index of the table */
    t->u.ind.t = (t->k == VLOCAL) ? t->u.var.ridx: t->u.info;
    if (isKstr(fs, k)) {
      t->u.ind.idx = k->u.info;  /* literal string */
      t->k = VINDEXSTR;
    }
    else if (isCint(k)) {
      t->u.ind.idx = cast_int(k->u.ival);  /* int. constant in proper range */
      t->k = VINDEXI;
    }
    else {
      t->u.ind.idx = luaK_exp2anyreg(fs, k);  /* register */
      t->k = VINDEXED;
    }
  }
}


/*
** Return false if folding can raise an error.
** Bitwise operations need operands convertible to integers; division
** operations cannot have 0 as divisor.
*/
static int validop (int op, TValue *v1, TValue *v2) {
  switch (op) {
    case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:
    case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: {  /* conversion errors */
      lua_Integer i;
      return (luaV_tointegerns(v1, &i, LUA_FLOORN2I) &&
              luaV_tointegerns(v2, &i, LUA_FLOORN2I));
    }
    case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD:  /* division by 0 */
      return (nvalue(v2) != 0);
    default: return 1;  /* everything else is valid */
  }
}


/*
** Try to ""constant-fold"" an operation; return 1 iff successful.
** (In this case, 'e1' has the final result.)
*/
static int constfolding (FuncState *fs, int op, expdesc *e1,
                                        const expdesc *e2) {
  TValue v1, v2, res;
  if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2))
    return 0;  /* non-numeric operands or not safe to fold */
  luaO_rawarith(fs->ls->L, op, &v1, &v2, &res);  /* does operation */
  if (ttisinteger(&res)) {
    e1->k = VKINT;
    e1->u.ival = ivalue(&res);
  }
  else {  /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */
    lua_Number n = fltvalue(&res);
    if (luai_numisnan(n) || n == 0)
      return 0;
    e1->k = VKFLT;
    e1->u.nval = n;
  }
  return 1;
}


/*
** Emit code for unary expressions that ""produce values""
** (everything but 'not').
** Expression to produce final result will be encoded in 'e'.
*/
static void codeunexpval (FuncState *fs, OpCode op, expdesc *e, int line) {
  int r = luaK_exp2anyreg(fs, e);  /* opcodes operate only on registers */
  freeexp(fs, e);
  e->u.info = luaK_codeABC(fs, op, 0, r, 0);  /* generate opcode */
  e->k = VRELOC;  /* all those operations are relocatable */
  luaK_fixline(fs, line);
}


/*
** Emit code for binary expressions that ""produce values""
** (everything but logical operators 'and'/'or' and comparison
** operators).
** Expression to produce final result will be encoded in 'e1'.
*/
static void finishbinexpval (FuncState *fs, expdesc *e1, expdesc *e2,
                             OpCode op, int v2, int flip, int line,
                             OpCode mmop, TMS event) {
  int v1 = luaK_exp2anyreg(fs, e1);
  int pc = luaK_codeABCk(fs, op, 0, v1, v2, 0);
  freeexps(fs, e1, e2);
  e1->u.info = pc;
  e1->k = VRELOC;  /* all those operations are relocatable */
  luaK_fixline(fs, line);
  luaK_codeABCk(fs, mmop, v1, v2, event, flip);  /* to call metamethod */
  luaK_fixline(fs, line);
}


/*
** Emit code for binary expressions that ""produce values"" over
** two registers.
*/
static void codebinexpval (FuncState *fs, OpCode op,
                           expdesc *e1, expdesc *e2, int line) {
  int v2 = luaK_exp2anyreg(fs, e2);  /* both operands are in registers */
  lua_assert(OP_ADD <= op && op <= OP_SHR);
  finishbinexpval(fs, e1, e2, op, v2, 0, line, OP_MMBIN,
                  cast(TMS, (op - OP_ADD) + TM_ADD));
}


/*
** Code binary operators with immediate operands.
*/
static void codebini (FuncState *fs, OpCode op,
                       expdesc *e1, expdesc *e2, int flip, int line,
                       TMS event) {
  int v2 = int2sC(cast_int(e2->u.ival));  /* immediate operand */
  lua_assert(e2->k == VKINT);
  finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINI, event);
}


/* Try to code a binary operator negating its second operand.
** For the metamethod, 2nd operand must keep its original value.
*/
static int finishbinexpneg (FuncState *fs, expdesc *e1, expdesc *e2,
                             OpCode op, int line, TMS event) {
  if (!luaK_isKint(e2))
    return 0;  /* not an integer constant */
  else {
    lua_Integer i2 = e2->u.ival;
    if (!(fitsC(i2) && fitsC(-i2)))
      return 0;  /* not in the proper range */
    else {  /* operating a small integer constant */
      int v2 = cast_int(i2);
      finishbinexpval(fs, e1, e2, op, int2sC(-v2), 0, line, OP_MMBINI, event);
      /* correct metamethod argument */
      SETARG_B(fs->f->code[fs->pc - 1], int2sC(v2));
      return 1;  /* successfully coded */
    }
  }
}


static void swapexps (expdesc *e1, expdesc *e2) {
  expdesc temp = *e1; *e1 = *e2; *e2 = temp;  /* swap 'e1' and 'e2' */
}


/*
** Code arithmetic operators ('+', '-', ...). If second operand is a
** constant in the proper range, use variant opcodes with K operands.
*/
static void codearith (FuncState *fs, BinOpr opr,
                       expdesc *e1, expdesc *e2, int flip, int line) {
  TMS event = cast(TMS, opr + TM_ADD);
  if (tonumeral(e2, NULL) && luaK_exp2K(fs, e2)) {  /* K operand? */
    int v2 = e2->u.info;  /* K index */
    OpCode op = cast(OpCode, opr + OP_ADDK);
    finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINK, event);
  }
  else {  /* 'e2' is neither an immediate nor a K operand */
    OpCode op = cast(OpCode, opr + OP_ADD);
    if (flip)
      swapexps(e1, e2);  /* back to original order */
    codebinexpval(fs, op, e1, e2, line);  /* use standard operators */
  }
}


/*
** Code commutative operators ('+', '*'). If first operand is a
** numeric constant, change order of operands to try to use an
** immediate or K operator.
*/
static void codecommutative (FuncState *fs, BinOpr op,
                             expdesc *e1, expdesc *e2, int line) {
  int flip = 0;
  if (tonumeral(e1, NULL)) {  /* is first operand a numeric constant? */
    swapexps(e1, e2);  /* change order */
    flip = 1;
  }
  if (op == OPR_ADD && isSCint(e2))  /* immediate operand? */
    codebini(fs, cast(OpCode, OP_ADDI), e1, e2, flip, line, TM_ADD);
  else
    codearith(fs, op, e1, e2, flip, line);
}


/*
** Code bitwise operations; they are all associative, so the function
** tries to put an integer constant as the 2nd operand (a K operand).
*/
static void codebitwise (FuncState *fs, BinOpr opr,
                         expdesc *e1, expdesc *e2, int line) {
  int flip = 0;
  int v2;
  OpCode op;
  if (e1->k == VKINT && luaK_exp2RK(fs, e1)) {
    swapexps(e1, e2);  /* 'e2' will be the constant operand */
    flip = 1;
  }
  else if (!(e2->k == VKINT && luaK_exp2RK(fs, e2))) {  /* no constants? */
    op = cast(OpCode, opr + OP_ADD);
    codebinexpval(fs, op, e1, e2, line);  /* all-register opcodes */
    return;
  }
  v2 = e2->u.info;  /* index in K array */
  op = cast(OpCode, opr + OP_ADDK);
  lua_assert(ttisinteger(&fs->f->k[v2]));
  finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINK,
                  cast(TMS, opr + TM_ADD));
}


/*
** Emit code for order comparisons. When using an immediate operand,
** 'isfloat' tells whether the original value was a float.
*/
static void codeorder (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2) {
  int r1, r2;
  int im;
  int isfloat = 0;
  if (isSCnumber(e2, &im, &isfloat)) {
    /* use immediate operand */
    r1 = luaK_exp2anyreg(fs, e1);
    r2 = im;
    op = cast(OpCode, (op - OP_LT) + OP_LTI);
  }
  else if (isSCnumber(e1, &im, &isfloat)) {
    /* transform (A < B) to (B > A) and (A <= B) to (B >= A) */
    r1 = luaK_exp2anyreg(fs, e2);
    r2 = im;
    op = (op == OP_LT) ? OP_GTI : OP_GEI;
  }
  else {  /* regular case, compare two registers */
    r1 = luaK_exp2anyreg(fs, e1);
    r2 = luaK_exp2anyreg(fs, e2);
  }
  freeexps(fs, e1, e2);
  e1->u.info = condjump(fs, op, r1, r2, isfloat, 1);
  e1->k = VJMP;
}


/*
** Emit code for equality comparisons ('==', '~=').
** 'e1' was already put as RK by 'luaK_infix'.
*/
static void codeeq (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) {
  int r1, r2;
  int im;
  int isfloat = 0;  /* not needed here, but kept for symmetry */
  OpCode op;
  if (e1->k != VNONRELOC) {
    lua_assert(e1->k == VK || e1->k == VKINT || e1->k == VKFLT);
    swapexps(e1, e2);
  }
  r1 = luaK_exp2anyreg(fs, e1);  /* 1st expression must be in register */
  if (isSCnumber(e2, &im, &isfloat)) {
    op = OP_EQI;
    r2 = im;  /* immediate operand */
  }
  else if (luaK_exp2RK(fs, e2)) {  /* 1st expression is constant? */
    op = OP_EQK;
    r2 = e2->u.info;  /* constant index */
  }
  else {
    op = OP_EQ;  /* will compare two registers */
    r2 = luaK_exp2anyreg(fs, e2);
  }
  freeexps(fs, e1, e2);
  e1->u.info = condjump(fs, op, r1, r2, isfloat, (opr == OPR_EQ));
  e1->k = VJMP;
}


/*
** Apply prefix operation 'op' to expression 'e'.
*/
void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e, int line) {
  static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP};
  luaK_dischargevars(fs, e);
  switch (op) {
    case OPR_MINUS: case OPR_BNOT:  /* use 'ef' as fake 2nd operand */
      if (constfolding(fs, op + LUA_OPUNM, e, &ef))
        break;
      /* else */ /* FALLTHROUGH */
    case OPR_LEN:
      codeunexpval(fs, cast(OpCode, op + OP_UNM), e, line);
      break;
    case OPR_NOT: codenot(fs, e); break;
    default: lua_assert(0);
  }
}


/*
** Process 1st operand 'v' of binary operation 'op' before reading
** 2nd operand.
*/
void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
  luaK_dischargevars(fs, v);
  switch (op) {
    case OPR_AND: {
      luaK_goiftrue(fs, v);  /* go ahead only if 'v' is true */
      break;
    }
    case OPR_OR: {
      luaK_goiffalse(fs, v);  /* go ahead only if 'v' is false */
      break;
    }
    case OPR_CONCAT: {
      luaK_exp2nextreg(fs, v);  /* operand must be on the stack */
      break;
    }
    case OPR_ADD: case OPR_SUB:
    case OPR_MUL: case OPR_DIV: case OPR_IDIV:
    case OPR_MOD: case OPR_POW:
    case OPR_BAND: case OPR_BOR: case OPR_BXOR:
    case OPR_SHL: case OPR_SHR: {
      if (!tonumeral(v, NULL))
        luaK_exp2anyreg(fs, v);
      /* else keep numeral, which may be folded with 2nd operand */
      break;
    }
    case OPR_EQ: case OPR_NE: {
      if (!tonumeral(v, NULL))
        luaK_exp2RK(fs, v);
      /* else keep numeral, which may be an immediate operand */
      break;
    }
    case OPR_LT: case OPR_LE:
    case OPR_GT: case OPR_GE: {
      int dummy, dummy2;
      if (!isSCnumber(v, &dummy, &dummy2))
        luaK_exp2anyreg(fs, v);
      /* else keep numeral, which may be an immediate operand */
      break;
    }
    default: lua_assert(0);
  }
}

/*
** Create code for '(e1 .. e2)'.
** For '(e1 .. e2.1 .. e2.2)' (which is '(e1 .. (e2.1 .. e2.2))',
** because concatenation is right associative), merge both CONCATs.
*/
static void codeconcat (FuncState *fs, expdesc *e1, expdesc *e2, int line) {
  Instruction *ie2 = previousinstruction(fs);
  if (GET_OPCODE(*ie2) == OP_CONCAT) {  /* is 'e2' a concatenation? */
    int n = GETARG_B(*ie2);  /* # of elements concatenated in 'e2' */
    lua_assert(e1->u.info + 1 == GETARG_A(*ie2));
    freeexp(fs, e2);
    SETARG_A(*ie2, e1->u.info);  /* correct first element ('e1') */
    SETARG_B(*ie2, n + 1);  /* will concatenate one more element */
  }
  else {  /* 'e2' is not a concatenation */
    luaK_codeABC(fs, OP_CONCAT, e1->u.info, 2, 0);  /* new concat opcode */
    freeexp(fs, e2);
    luaK_fixline(fs, line);
  }
}


/*
** Finalize code for binary operation, after reading 2nd operand.
*/
void luaK_posfix (FuncState *fs, BinOpr opr,
                  expdesc *e1, expdesc *e2, int line) {
  luaK_dischargevars(fs, e2);
  if (foldbinop(opr) && constfolding(fs, opr + LUA_OPADD, e1, e2))
    return;  /* done by folding */
  switch (opr) {
    case OPR_AND: {
      lua_assert(e1->t == NO_JUMP);  /* list closed by 'luaK_infix' */
      luaK_concat(fs, &e2->f, e1->f);
      *e1 = *e2;
      break;
    }
    case OPR_OR: {
      lua_assert(e1->f == NO_JUMP);  /* list closed by 'luaK_infix' */
      luaK_concat(fs, &e2->t, e1->t);
      *e1 = *e2;
      break;
    }
    case OPR_CONCAT: {  /* e1 .. e2 */
      luaK_exp2nextreg(fs, e2);
      codeconcat(fs, e1, e2, line);
      break;
    }
    case OPR_ADD: case OPR_MUL: {
      codecommutative(fs, opr, e1, e2, line);
      break;
    }
    case OPR_SUB: {
      if (finishbinexpneg(fs, e1, e2, OP_ADDI, line, TM_SUB))
        break; /* coded as (r1 + -I) */
      /* ELSE */
    }  /* FALLTHROUGH */
    case OPR_DIV: case OPR_IDIV: case OPR_MOD: case OPR_POW: {
      codearith(fs, opr, e1, e2, 0, line);
      break;
    }
    case OPR_BAND: case OPR_BOR: case OPR_BXOR: {
      codebitwise(fs, opr, e1, e2, line);
      break;
    }
    case OPR_SHL: {
      if (isSCint(e1)) {
        swapexps(e1, e2);
        codebini(fs, OP_SHLI, e1, e2, 1, line, TM_SHL);  /* I << r2 */
      }
      else if (finishbinexpneg(fs, e1, e2, OP_SHRI, line, TM_SHL)) {
        /* coded as (r1 >> -I) */;
      }
      else  /* regular case (two registers) */
       codebinexpval(fs, OP_SHL, e1, e2, line);
      break;
    }
    case OPR_SHR: {
      if (isSCint(e2))
        codebini(fs, OP_SHRI, e1, e2, 0, line, TM_SHR);  /* r1 >> I */
      else  /* regular case (two registers) */
        codebinexpval(fs, OP_SHR, e1, e2, line);
      break;
    }
    case OPR_EQ: case OPR_NE: {
      codeeq(fs, opr, e1, e2);
      break;
    }
    case OPR_LT: case OPR_LE: {
      OpCode op = cast(OpCode, (opr - OPR_EQ) + OP_EQ);
      codeorder(fs, op, e1, e2);
      break;
    }
    case OPR_GT: case OPR_GE: {
      /* '(a > b)' <=> '(b < a)';  '(a >= b)' <=> '(b <= a)' */
      OpCode op = cast(OpCode, (opr - OPR_NE) + OP_EQ);
      swapexps(e1, e2);
      codeorder(fs, op, e1, e2);
      break;
    }
    default: lua_assert(0);
  }
}


/*
** Change line information associated with current position, by removing
** previous info and adding it again with new line.
*/
void luaK_fixline (FuncState *fs, int line) {
  removelastlineinfo(fs);
  savelineinfo(fs, fs->f, line);
}


void luaK_settablesize (FuncState *fs, int pc, int ra, int asize, int hsize) {
  Instruction *inst = &fs->f->code[pc];
  int rb = (hsize != 0) ? luaO_ceillog2(hsize) + 1 : 0;  /* hash size */
  int extra = asize / (MAXARG_C + 1);  /* higher bits of array size */
  int rc = asize % (MAXARG_C + 1);  /* lower bits of array size */
  int k = (extra > 0);  /* true iff needs extra argument */
  *inst = CREATE_ABCk(OP_NEWTABLE, ra, rb, rc, k);
  *(inst + 1) = CREATE_Ax(OP_EXTRAARG, extra);
}


/*
** Emit a SETLIST instruction.
** 'base' is register that keeps table;
** 'nelems' is #table plus those to be stored now;
** 'tostore' is number of values (in registers 'base + 1',...) to add to
** table (or LUA_MULTRET to add up to stack top).
*/
void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
  lua_assert(tostore != 0 && tostore <= LFIELDS_PER_FLUSH);
  if (tostore == LUA_MULTRET)
    tostore = 0;
  if (nelems <= MAXARG_C)
    luaK_codeABC(fs, OP_SETLIST, base, tostore, nelems);
  else {
    int extra = nelems / (MAXARG_C + 1);
    nelems %= (MAXARG_C + 1);
    luaK_codeABCk(fs, OP_SETLIST, base, tostore, nelems, 1);
    codeextraarg(fs, extra);
  }
  fs->freereg = base + 1;  /* free registers with list values */
}


/*
** return the final target of a jump (skipping jumps to jumps)
*/
static int finaltarget (Instruction *code, int i) {
  int count;
  for (count = 0; count < 100; count++) {  /* avoid infinite loops */
    Instruction pc = code[i];
    if (GET_OPCODE(pc) != OP_JMP)
      break;
     else
       i += GETARG_sJ(pc) + 1;
  }
  return i;
}


/*
** Do a final pass over the code of a function, doing small peephole
** optimizations and adjustments.
*/
void luaK_finish (FuncState *fs) {
  int i;
  Proto *p = fs->f;
  for (i = 0; i < fs->pc; i++) {
    Instruction *pc = &p->code[i];
    lua_assert(i == 0 || isOT(*(pc - 1)) == isIT(*pc));
    switch (GET_OPCODE(*pc)) {
      case OP_RETURN0: case OP_RETURN1: {
        if (!(fs->needclose || p->is_vararg))
          break;  /* no extra work */
        /* else use OP_RETURN to do the extra work */
        SET_OPCODE(*pc, OP_RETURN);
      }  /* FALLTHROUGH */
      case OP_RETURN: case OP_TAILCALL: {
        if (fs->needclose)
          SETARG_k(*pc, 1);  /* signal that it needs to close */
        if (p->is_vararg)
          SETARG_C(*pc, p->numparams + 1);  /* signal that it is vararg */
        break;
      }
      case OP_JMP: {
        int target = finaltarget(p->code, i);
        fixjump(fs, i, target);
        break;
      }
      default: break;
    }
  }
}
",16252,True,3396.0530756184344,median
"/*
* Copyright (c) 2003-2020 Rony Shapiro <ronys@pwsafe.org>.
* All rights reserved. Use of the code is allowed under the
* Artistic License 2.0 terms, as specified in the LICENSE file
* distributed with this code, or available from
* http://www.opensource.org/licenses/artistic-license-2.0.php
*/

/*
 * unicode2keysym - Contains a map between UNICODE wchar_t values and X keysyms
 *
 * This file is auto-generated using Misc/unicode2keysym.pl.  Do not edit by hand!!
 *
 */

#include <X11/Intrinsic.h>
#include ""./unicode2keysym.h""

KeySym unicode2keysym(wchar_t wc)
{
  switch (wc) {
	case 0x0100: return 0x03c0;		// Amacron
	case 0x0101: return 0x03e0;		// amacron
	case 0x0102: return 0x01c3;		// Abreve
	case 0x0103: return 0x01e3;		// abreve
	case 0x0104: return 0x01a1;		// Aogonek
	case 0x0105: return 0x01b1;		// aogonek
	case 0x0106: return 0x01c6;		// Cacute
	case 0x0107: return 0x01e6;		// cacute
	case 0x0108: return 0x02c6;		// Ccircumflex
	case 0x0109: return 0x02e6;		// ccircumflex
	case 0x010A: return 0x02c5;		// Cabovedot
	case 0x010B: return 0x02e5;		// cabovedot
	case 0x010C: return 0x01c8;		// Ccaron
	case 0x010D: return 0x01e8;		// ccaron
	case 0x010E: return 0x01cf;		// Dcaron
	case 0x010F: return 0x01ef;		// dcaron
	case 0x0110: return 0x01d0;		// Dstroke
	case 0x0111: return 0x01f0;		// dstroke
	case 0x0112: return 0x03aa;		// Emacron
	case 0x0113: return 0x03ba;		// emacron
	case 0x0116: return 0x03cc;		// Eabovedot
	case 0x0117: return 0x03ec;		// eabovedot
	case 0x0118: return 0x01ca;		// Eogonek
	case 0x0119: return 0x01ea;		// eogonek
	case 0x011A: return 0x01cc;		// Ecaron
	case 0x011B: return 0x01ec;		// ecaron
	case 0x011C: return 0x02d8;		// Gcircumflex
	case 0x011D: return 0x02f8;		// gcircumflex
	case 0x011E: return 0x02ab;		// Gbreve
	case 0x011F: return 0x02bb;		// gbreve
	case 0x0120: return 0x02d5;		// Gabovedot
	case 0x0121: return 0x02f5;		// gabovedot
	case 0x0122: return 0x03ab;		// Gcedilla
	case 0x0123: return 0x03bb;		// gcedilla
	case 0x0124: return 0x02a6;		// Hcircumflex
	case 0x0125: return 0x02b6;		// hcircumflex
	case 0x0126: return 0x02a1;		// Hstroke
	case 0x0127: return 0x02b1;		// hstroke
	case 0x0128: return 0x03a5;		// Itilde
	case 0x0129: return 0x03b5;		// itilde
	case 0x012A: return 0x03cf;		// Imacron
	case 0x012B: return 0x03ef;		// imacron
	case 0x012E: return 0x03c7;		// Iogonek
	case 0x012F: return 0x03e7;		// iogonek
	case 0x0130: return 0x02a9;		// Iabovedot
	case 0x0131: return 0x02b9;		// idotless
	case 0x0134: return 0x02ac;		// Jcircumflex
	case 0x0135: return 0x02bc;		// jcircumflex
	case 0x0136: return 0x03d3;		// Kcedilla
	case 0x0137: return 0x03f3;		// kcedilla
	case 0x0138: return 0x03a2;		// kra
	case 0x0139: return 0x01c5;		// Lacute
	case 0x013A: return 0x01e5;		// lacute
	case 0x013B: return 0x03a6;		// Lcedilla
	case 0x013C: return 0x03b6;		// lcedilla
	case 0x013D: return 0x01a5;		// Lcaron
	case 0x013E: return 0x01b5;		// lcaron
	case 0x0141: return 0x01a3;		// Lstroke
	case 0x0142: return 0x01b3;		// lstroke
	case 0x0143: return 0x01d1;		// Nacute
	case 0x0144: return 0x01f1;		// nacute
	case 0x0145: return 0x03d1;		// Ncedilla
	case 0x0146: return 0x03f1;		// ncedilla
	case 0x0147: return 0x01d2;		// Ncaron
	case 0x0148: return 0x01f2;		// ncaron
	case 0x014A: return 0x03bd;		// ENG
	case 0x014B: return 0x03bf;		// eng
	case 0x014C: return 0x03d2;		// Omacron
	case 0x014D: return 0x03f2;		// omacron
	case 0x0150: return 0x01d5;		// Odoubleacute
	case 0x0151: return 0x01f5;		// odoubleacute
	case 0x0152: return 0x13bc;		// OE
	case 0x0153: return 0x13bd;		// oe
	case 0x0154: return 0x01c0;		// Racute
	case 0x0155: return 0x01e0;		// racute
	case 0x0156: return 0x03a3;		// Rcedilla
	case 0x0157: return 0x03b3;		// rcedilla
	case 0x0158: return 0x01d8;		// Rcaron
	case 0x0159: return 0x01f8;		// rcaron
	case 0x015A: return 0x01a6;		// Sacute
	case 0x015B: return 0x01b6;		// sacute
	case 0x015C: return 0x02de;		// Scircumflex
	case 0x015D: return 0x02fe;		// scircumflex
	case 0x015E: return 0x01aa;		// Scedilla
	case 0x015F: return 0x01ba;		// scedilla
	case 0x0160: return 0x01a9;		// Scaron
	case 0x0161: return 0x01b9;		// scaron
	case 0x0162: return 0x01de;		// Tcedilla
	case 0x0163: return 0x01fe;		// tcedilla
	case 0x0164: return 0x01ab;		// Tcaron
	case 0x0165: return 0x01bb;		// tcaron
	case 0x0166: return 0x03ac;		// Tslash
	case 0x0167: return 0x03bc;		// tslash
	case 0x0168: return 0x03dd;		// Utilde
	case 0x0169: return 0x03fd;		// utilde
	case 0x016A: return 0x03de;		// Umacron
	case 0x016B: return 0x03fe;		// umacron
	case 0x016C: return 0x02dd;		// Ubreve
	case 0x016D: return 0x02fd;		// ubreve
	case 0x016E: return 0x01d9;		// Uring
	case 0x016F: return 0x01f9;		// uring
	case 0x0170: return 0x01db;		// Udoubleacute
	case 0x0171: return 0x01fb;		// udoubleacute
	case 0x0172: return 0x03d9;		// Uogonek
	case 0x0173: return 0x03f9;		// uogonek
	case 0x0178: return 0x13be;		// Ydiaeresis
	case 0x0179: return 0x01ac;		// Zacute
	case 0x017A: return 0x01bc;		// zacute
	case 0x017B: return 0x01af;		// Zabovedot
	case 0x017C: return 0x01bf;		// zabovedot
	case 0x017D: return 0x01ae;		// Zcaron
	case 0x017E: return 0x01be;		// zcaron
	case 0x0192: return 0x08f6;		// function
	case 0x02C7: return 0x01b7;		// caron
	case 0x02D8: return 0x01a2;		// breve
	case 0x02D9: return 0x01ff;		// abovedot
	case 0x02DB: return 0x01b2;		// ogonek
	case 0x02DD: return 0x01bd;		// doubleacute
	case 0x0385: return 0x07ae;		// Greek_accentdieresis
	case 0x0386: return 0x07a1;		// Greek_ALPHAaccent
	case 0x0388: return 0x07a2;		// Greek_EPSILONaccent
	case 0x0389: return 0x07a3;		// Greek_ETAaccent
	case 0x038A: return 0x07a4;		// Greek_IOTAaccent
	case 0x038C: return 0x07a7;		// Greek_OMICRONaccent
	case 0x038E: return 0x07a8;		// Greek_UPSILONaccent
	case 0x038F: return 0x07ab;		// Greek_OMEGAaccent
	case 0x0390: return 0x07b6;		// Greek_iotaaccentdieresis
	case 0x0391: return 0x07c1;		// Greek_ALPHA
	case 0x0392: return 0x07c2;		// Greek_BETA
	case 0x0393: return 0x07c3;		// Greek_GAMMA
	case 0x0394: return 0x07c4;		// Greek_DELTA
	case 0x0395: return 0x07c5;		// Greek_EPSILON
	case 0x0396: return 0x07c6;		// Greek_ZETA
	case 0x0397: return 0x07c7;		// Greek_ETA
	case 0x0398: return 0x07c8;		// Greek_THETA
	case 0x0399: return 0x07c9;		// Greek_IOTA
	case 0x039A: return 0x07ca;		// Greek_KAPPA
	case 0x039B: return 0x07cb;		// Greek_LAMBDA
	case 0x039C: return 0x07cc;		// Greek_MU
	case 0x039D: return 0x07cd;		// Greek_NU
	case 0x039E: return 0x07ce;		// Greek_XI
	case 0x039F: return 0x07cf;		// Greek_OMICRON
	case 0x03A0: return 0x07d0;		// Greek_PI
	case 0x03A1: return 0x07d1;		// Greek_RHO
	case 0x03A3: return 0x07d2;		// Greek_SIGMA
	case 0x03A4: return 0x07d4;		// Greek_TAU
	case 0x03A5: return 0x07d5;		// Greek_UPSILON
	case 0x03A6: return 0x07d6;		// Greek_PHI
	case 0x03A7: return 0x07d7;		// Greek_CHI
	case 0x03A8: return 0x07d8;		// Greek_PSI
	case 0x03A9: return 0x07d9;		// Greek_OMEGA
	case 0x03AA: return 0x07a5;		// Greek_IOTAdieresis
	case 0x03AB: return 0x07a9;		// Greek_UPSILONdieresis
	case 0x03AC: return 0x07b1;		// Greek_alphaaccent
	case 0x03AD: return 0x07b2;		// Greek_epsilonaccent
	case 0x03AE: return 0x07b3;		// Greek_etaaccent
	case 0x03AF: return 0x07b4;		// Greek_iotaaccent
	case 0x03B0: return 0x07ba;		// Greek_upsilonaccentdieresis
	case 0x03B1: return 0x07e1;		// Greek_alpha
	case 0x03B2: return 0x07e2;		// Greek_beta
	case 0x03B3: return 0x07e3;		// Greek_gamma
	case 0x03B4: return 0x07e4;		// Greek_delta
	case 0x03B5: return 0x07e5;		// Greek_epsilon
	case 0x03B6: return 0x07e6;		// Greek_zeta
	case 0x03B7: return 0x07e7;		// Greek_eta
	case 0x03B8: return 0x07e8;		// Greek_theta
	case 0x03B9: return 0x07e9;		// Greek_iota
	case 0x03BA: return 0x07ea;		// Greek_kappa
	case 0x03BB: return 0x07eb;		// Greek_lambda
	case 0x03BC: return 0x07ec;		// Greek_mu
	case 0x03BD: return 0x07ed;		// Greek_nu
	case 0x03BE: return 0x07ee;		// Greek_xi
	case 0x03BF: return 0x07ef;		// Greek_omicron
	case 0x03C0: return 0x07f0;		// Greek_pi
	case 0x03C1: return 0x07f1;		// Greek_rho
	case 0x03C2: return 0x07f3;		// Greek_finalsmallsigma
	case 0x03C3: return 0x07f2;		// Greek_sigma
	case 0x03C4: return 0x07f4;		// Greek_tau
	case 0x03C5: return 0x07f5;		// Greek_upsilon
	case 0x03C6: return 0x07f6;		// Greek_phi
	case 0x03C7: return 0x07f7;		// Greek_chi
	case 0x03C8: return 0x07f8;		// Greek_psi
	case 0x03C9: return 0x07f9;		// Greek_omega
	case 0x03CA: return 0x07b5;		// Greek_iotadieresis
	case 0x03CB: return 0x07b9;		// Greek_upsilondieresis
	case 0x03CC: return 0x07b7;		// Greek_omicronaccent
	case 0x03CD: return 0x07b8;		// Greek_upsilonaccent
	case 0x03CE: return 0x07bb;		// Greek_omegaaccent
	case 0x0401: return 0x06b3;		// Cyrillic_IO
	case 0x0402: return 0x06b1;		// Serbian_DJE
	case 0x0403: return 0x06b2;		// Macedonia_GJE
	case 0x0404: return 0x06b4;		// Ukrainian_IE
	case 0x0405: return 0x06b5;		// Macedonia_DSE
	case 0x0406: return 0x06b6;		// Ukrainian_I
	case 0x0407: return 0x06b7;		// Ukrainian_YI
	case 0x0408: return 0x06b8;		// Cyrillic_JE
	case 0x0409: return 0x06b9;		// Cyrillic_LJE
	case 0x040A: return 0x06ba;		// Cyrillic_NJE
	case 0x040B: return 0x06bb;		// Serbian_TSHE
	case 0x040C: return 0x06bc;		// Macedonia_KJE
	case 0x040E: return 0x06be;		// Byelorussian_SHORTU
	case 0x040F: return 0x06bf;		// Cyrillic_DZHE
	case 0x0410: return 0x06e1;		// Cyrillic_A
	case 0x0411: return 0x06e2;		// Cyrillic_BE
	case 0x0412: return 0x06f7;		// Cyrillic_VE
	case 0x0413: return 0x06e7;		// Cyrillic_GHE
	case 0x0414: return 0x06e4;		// Cyrillic_DE
	case 0x0415: return 0x06e5;		// Cyrillic_IE
	case 0x0416: return 0x06f6;		// Cyrillic_ZHE
	case 0x0417: return 0x06fa;		// Cyrillic_ZE
	case 0x0418: return 0x06e9;		// Cyrillic_I
	case 0x0419: return 0x06ea;		// Cyrillic_SHORTI
	case 0x041A: return 0x06eb;		// Cyrillic_KA
	case 0x041B: return 0x06ec;		// Cyrillic_EL
	case 0x041C: return 0x06ed;		// Cyrillic_EM
	case 0x041D: return 0x06ee;		// Cyrillic_EN
	case 0x041E: return 0x06ef;		// Cyrillic_O
	case 0x041F: return 0x06f0;		// Cyrillic_PE
	case 0x0420: return 0x06f2;		// Cyrillic_ER
	case 0x0421: return 0x06f3;		// Cyrillic_ES
	case 0x0422: return 0x06f4;		// Cyrillic_TE
	case 0x0423: return 0x06f5;		// Cyrillic_U
	case 0x0424: return 0x06e6;		// Cyrillic_EF
	case 0x0425: return 0x06e8;		// Cyrillic_HA
	case 0x0426: return 0x06e3;		// Cyrillic_TSE
	case 0x0427: return 0x06fe;		// Cyrillic_CHE
	case 0x0428: return 0x06fb;		// Cyrillic_SHA
	case 0x0429: return 0x06fd;		// Cyrillic_SHCHA
	case 0x042A: return 0x06ff;		// Cyrillic_HARDSIGN
	case 0x042B: return 0x06f9;		// Cyrillic_YERU
	case 0x042C: return 0x06f8;		// Cyrillic_SOFTSIGN
	case 0x042D: return 0x06fc;		// Cyrillic_E
	case 0x042E: return 0x06e0;		// Cyrillic_YU
	case 0x042F: return 0x06f1;		// Cyrillic_YA
	case 0x0430: return 0x06c1;		// Cyrillic_a
	case 0x0431: return 0x06c2;		// Cyrillic_be
	case 0x0432: return 0x06d7;		// Cyrillic_ve
	case 0x0433: return 0x06c7;		// Cyrillic_ghe
	case 0x0434: return 0x06c4;		// Cyrillic_de
	case 0x0435: return 0x06c5;		// Cyrillic_ie
	case 0x0436: return 0x06d6;		// Cyrillic_zhe
	case 0x0437: return 0x06da;		// Cyrillic_ze
	case 0x0438: return 0x06c9;		// Cyrillic_i
	case 0x0439: return 0x06ca;		// Cyrillic_shorti
	case 0x043A: return 0x06cb;		// Cyrillic_ka
	case 0x043B: return 0x06cc;		// Cyrillic_el
	case 0x043C: return 0x06cd;		// Cyrillic_em
	case 0x043D: return 0x06ce;		// Cyrillic_en
	case 0x043E: return 0x06cf;		// Cyrillic_o
	case 0x043F: return 0x06d0;		// Cyrillic_pe
	case 0x0440: return 0x06d2;		// Cyrillic_er
	case 0x0441: return 0x06d3;		// Cyrillic_es
	case 0x0442: return 0x06d4;		// Cyrillic_te
	case 0x0443: return 0x06d5;		// Cyrillic_u
	case 0x0444: return 0x06c6;		// Cyrillic_ef
	case 0x0445: return 0x06c8;		// Cyrillic_ha
	case 0x0446: return 0x06c3;		// Cyrillic_tse
	case 0x0447: return 0x06de;		// Cyrillic_che
	case 0x0448: return 0x06db;		// Cyrillic_sha
	case 0x0449: return 0x06dd;		// Cyrillic_shcha
	case 0x044A: return 0x06df;		// Cyrillic_hardsign
	case 0x044B: return 0x06d9;		// Cyrillic_yeru
	case 0x044C: return 0x06d8;		// Cyrillic_softsign
	case 0x044D: return 0x06dc;		// Cyrillic_e
	case 0x044E: return 0x06c0;		// Cyrillic_yu
	case 0x044F: return 0x06d1;		// Cyrillic_ya
	case 0x0451: return 0x06a3;		// Cyrillic_io
	case 0x0452: return 0x06a1;		// Serbian_dje
	case 0x0453: return 0x06a2;		// Macedonia_gje
	case 0x0454: return 0x06a4;		// Ukrainian_ie
	case 0x0455: return 0x06a5;		// Macedonia_dse
	case 0x0456: return 0x06a6;		// Ukrainian_i
	case 0x0457: return 0x06a7;		// Ukrainian_yi
	case 0x0458: return 0x06a8;		// Cyrillic_je
	case 0x0459: return 0x06a9;		// Cyrillic_lje
	case 0x045A: return 0x06aa;		// Cyrillic_nje
	case 0x045B: return 0x06ab;		// Serbian_tshe
	case 0x045C: return 0x06ac;		// Macedonia_kje
	case 0x045E: return 0x06ae;		// Byelorussian_shortu
	case 0x045F: return 0x06af;		// Cyrillic_dzhe
	case 0x0490: return 0x06bd;		// Ukrainian_GHE_WITH_UPTURN
	case 0x0491: return 0x06ad;		// Ukrainian_ghe_with_upturn
	case 0x05D0: return 0x0ce0;		// hebrew_aleph
	case 0x05D1: return 0x0ce1;		// hebrew_bet
	case 0x05D2: return 0x0ce2;		// hebrew_gimel
	case 0x05D3: return 0x0ce3;		// hebrew_dalet
	case 0x05D4: return 0x0ce4;		// hebrew_he
	case 0x05D5: return 0x0ce5;		// hebrew_waw
	case 0x05D6: return 0x0ce6;		// hebrew_zain
	case 0x05D7: return 0x0ce7;		// hebrew_chet
	case 0x05D8: return 0x0ce8;		// hebrew_tet
	case 0x05D9: return 0x0ce9;		// hebrew_yod
	case 0x05DA: return 0x0cea;		// hebrew_finalkaph
	case 0x05DB: return 0x0ceb;		// hebrew_kaph
	case 0x05DC: return 0x0cec;		// hebrew_lamed
	case 0x05DD: return 0x0ced;		// hebrew_finalmem
	case 0x05DE: return 0x0cee;		// hebrew_mem
	case 0x05DF: return 0x0cef;		// hebrew_finalnun
	case 0x05E0: return 0x0cf0;		// hebrew_nun
	case 0x05E1: return 0x0cf1;		// hebrew_samech
	case 0x05E2: return 0x0cf2;		// hebrew_ayin
	case 0x05E3: return 0x0cf3;		// hebrew_finalpe
	case 0x05E4: return 0x0cf4;		// hebrew_pe
	case 0x05E5: return 0x0cf5;		// hebrew_finalzade
	case 0x05E6: return 0x0cf6;		// hebrew_zade
	case 0x05E7: return 0x0cf7;		// hebrew_qoph
	case 0x05E8: return 0x0cf8;		// hebrew_resh
	case 0x05E9: return 0x0cf9;		// hebrew_shin
	case 0x05EA: return 0x0cfa;		// hebrew_taw
	case 0x060C: return 0x05ac;		// Arabic_comma
	case 0x061B: return 0x05bb;		// Arabic_semicolon
	case 0x061F: return 0x05bf;		// Arabic_question_mark
	case 0x0621: return 0x05c1;		// Arabic_hamza
	case 0x0622: return 0x05c2;		// Arabic_maddaonalef
	case 0x0623: return 0x05c3;		// Arabic_hamzaonalef
	case 0x0624: return 0x05c4;		// Arabic_hamzaonwaw
	case 0x0625: return 0x05c5;		// Arabic_hamzaunderalef
	case 0x0626: return 0x05c6;		// Arabic_hamzaonyeh
	case 0x0627: return 0x05c7;		// Arabic_alef
	case 0x0628: return 0x05c8;		// Arabic_beh
	case 0x0629: return 0x05c9;		// Arabic_tehmarbuta
	case 0x062A: return 0x05ca;		// Arabic_teh
	case 0x062B: return 0x05cb;		// Arabic_theh
	case 0x062C: return 0x05cc;		// Arabic_jeem
	case 0x062D: return 0x05cd;		// Arabic_hah
	case 0x062E: return 0x05ce;		// Arabic_khah
	case 0x062F: return 0x05cf;		// Arabic_dal
	case 0x0630: return 0x05d0;		// Arabic_thal
	case 0x0631: return 0x05d1;		// Arabic_ra
	case 0x0632: return 0x05d2;		// Arabic_zain
	case 0x0633: return 0x05d3;		// Arabic_seen
	case 0x0634: return 0x05d4;		// Arabic_sheen
	case 0x0635: return 0x05d5;		// Arabic_sad
	case 0x0636: return 0x05d6;		// Arabic_dad
	case 0x0637: return 0x05d7;		// Arabic_tah
	case 0x0638: return 0x05d8;		// Arabic_zah
	case 0x0639: return 0x05d9;		// Arabic_ain
	case 0x063A: return 0x05da;		// Arabic_ghain
	case 0x0640: return 0x05e0;		// Arabic_tatweel
	case 0x0641: return 0x05e1;		// Arabic_feh
	case 0x0642: return 0x05e2;		// Arabic_qaf
	case 0x0643: return 0x05e3;		// Arabic_kaf
	case 0x0644: return 0x05e4;		// Arabic_lam
	case 0x0645: return 0x05e5;		// Arabic_meem
	case 0x0646: return 0x05e6;		// Arabic_noon
	case 0x0647: return 0x05e7;		// Arabic_ha
	case 0x0648: return 0x05e8;		// Arabic_waw
	case 0x0649: return 0x05e9;		// Arabic_alefmaksura
	case 0x064A: return 0x05ea;		// Arabic_yeh
	case 0x064B: return 0x05eb;		// Arabic_fathatan
	case 0x064C: return 0x05ec;		// Arabic_dammatan
	case 0x064D: return 0x05ed;		// Arabic_kasratan
	case 0x064E: return 0x05ee;		// Arabic_fatha
	case 0x064F: return 0x05ef;		// Arabic_damma
	case 0x0650: return 0x05f0;		// Arabic_kasra
	case 0x0651: return 0x05f1;		// Arabic_shadda
	case 0x0652: return 0x05f2;		// Arabic_sukun
	case 0x0E01: return 0x0da1;		// Thai_kokai
	case 0x0E02: return 0x0da2;		// Thai_khokhai
	case 0x0E03: return 0x0da3;		// Thai_khokhuat
	case 0x0E04: return 0x0da4;		// Thai_khokhwai
	case 0x0E05: return 0x0da5;		// Thai_khokhon
	case 0x0E06: return 0x0da6;		// Thai_khorakhang
	case 0x0E07: return 0x0da7;		// Thai_ngongu
	case 0x0E08: return 0x0da8;		// Thai_chochan
	case 0x0E09: return 0x0da9;		// Thai_choching
	case 0x0E0A: return 0x0daa;		// Thai_chochang
	case 0x0E0B: return 0x0dab;		// Thai_soso
	case 0x0E0C: return 0x0dac;		// Thai_chochoe
	case 0x0E0D: return 0x0dad;		// Thai_yoying
	case 0x0E0E: return 0x0dae;		// Thai_dochada
	case 0x0E0F: return 0x0daf;		// Thai_topatak
	case 0x0E10: return 0x0db0;		// Thai_thothan
	case 0x0E11: return 0x0db1;		// Thai_thonangmontho
	case 0x0E12: return 0x0db2;		// Thai_thophuthao
	case 0x0E13: return 0x0db3;		// Thai_nonen
	case 0x0E14: return 0x0db4;		// Thai_dodek
	case 0x0E15: return 0x0db5;		// Thai_totao
	case 0x0E16: return 0x0db6;		// Thai_thothung
	case 0x0E17: return 0x0db7;		// Thai_thothahan
	case 0x0E18: return 0x0db8;		// Thai_thothong
	case 0x0E19: return 0x0db9;		// Thai_nonu
	case 0x0E1A: return 0x0dba;		// Thai_bobaimai
	case 0x0E1B: return 0x0dbb;		// Thai_popla
	case 0x0E1C: return 0x0dbc;		// Thai_phophung
	case 0x0E1D: return 0x0dbd;		// Thai_fofa
	case 0x0E1E: return 0x0dbe;		// Thai_phophan
	case 0x0E1F: return 0x0dbf;		// Thai_fofan
	case 0x0E20: return 0x0dc0;		// Thai_phosamphao
	case 0x0E21: return 0x0dc1;		// Thai_moma
	case 0x0E22: return 0x0dc2;		// Thai_yoyak
	case 0x0E23: return 0x0dc3;		// Thai_rorua
	case 0x0E24: return 0x0dc4;		// Thai_ru
	case 0x0E25: return 0x0dc5;		// Thai_loling
	case 0x0E26: return 0x0dc6;		// Thai_lu
	case 0x0E27: return 0x0dc7;		// Thai_wowaen
	case 0x0E28: return 0x0dc8;		// Thai_sosala
	case 0x0E29: return 0x0dc9;		// Thai_sorusi
	case 0x0E2A: return 0x0dca;		// Thai_sosua
	case 0x0E2B: return 0x0dcb;		// Thai_hohip
	case 0x0E2C: return 0x0dcc;		// Thai_lochula
	case 0x0E2D: return 0x0dcd;		// Thai_oang
	case 0x0E2E: return 0x0dce;		// Thai_honokhuk
	case 0x0E2F: return 0x0dcf;		// Thai_paiyannoi
	case 0x0E30: return 0x0dd0;		// Thai_saraa
	case 0x0E31: return 0x0dd1;		// Thai_maihanakat
	case 0x0E32: return 0x0dd2;		// Thai_saraaa
	case 0x0E33: return 0x0dd3;		// Thai_saraam
	case 0x0E34: return 0x0dd4;		// Thai_sarai
	case 0x0E35: return 0x0dd5;		// Thai_saraii
	case 0x0E36: return 0x0dd6;		// Thai_saraue
	case 0x0E37: return 0x0dd7;		// Thai_sarauee
	case 0x0E38: return 0x0dd8;		// Thai_sarau
	case 0x0E39: return 0x0dd9;		// Thai_sarauu
	case 0x0E3A: return 0x0dda;		// Thai_phinthu
	case 0x0E3F: return 0x0ddf;		// Thai_baht
	case 0x0E40: return 0x0de0;		// Thai_sarae
	case 0x0E41: return 0x0de1;		// Thai_saraae
	case 0x0E42: return 0x0de2;		// Thai_sarao
	case 0x0E43: return 0x0de3;		// Thai_saraaimaimuan
	case 0x0E44: return 0x0de4;		// Thai_saraaimaimalai
	case 0x0E45: return 0x0de5;		// Thai_lakkhangyao
	case 0x0E46: return 0x0de6;		// Thai_maiyamok
	case 0x0E47: return 0x0de7;		// Thai_maitaikhu
	case 0x0E48: return 0x0de8;		// Thai_maiek
	case 0x0E49: return 0x0de9;		// Thai_maitho
	case 0x0E4A: return 0x0dea;		// Thai_maitri
	case 0x0E4B: return 0x0deb;		// Thai_maichattawa
	case 0x0E4C: return 0x0dec;		// Thai_thanthakhat
	case 0x0E4D: return 0x0ded;		// Thai_nikhahit
	case 0x0E50: return 0x0df0;		// Thai_leksun
	case 0x0E51: return 0x0df1;		// Thai_leknung
	case 0x0E52: return 0x0df2;		// Thai_leksong
	case 0x0E53: return 0x0df3;		// Thai_leksam
	case 0x0E54: return 0x0df4;		// Thai_leksi
	case 0x0E55: return 0x0df5;		// Thai_lekha
	case 0x0E56: return 0x0df6;		// Thai_lekhok
	case 0x0E57: return 0x0df7;		// Thai_lekchet
	case 0x0E58: return 0x0df8;		// Thai_lekpaet
	case 0x0E59: return 0x0df9;		// Thai_lekkao
	case 0x2002: return 0x0aa2;		// enspace
	case 0x2003: return 0x0aa1;		// emspace
	case 0x2004: return 0x0aa3;		// em3space
	case 0x2005: return 0x0aa4;		// em4space
	case 0x2007: return 0x0aa5;		// digitspace
	case 0x2008: return 0x0aa6;		// punctspace
	case 0x2009: return 0x0aa7;		// thinspace
	case 0x200A: return 0x0aa8;		// hairspace
	case 0x2012: return 0x0abb;		// figdash
	case 0x2013: return 0x0aaa;		// endash
	case 0x2014: return 0x0aa9;		// emdash
	case 0x2015: return 0x07af;		// Greek_horizbar
	case 0x2017: return 0x0cdf;		// hebrew_doublelowline
	case 0x2018: return 0x0ad0;		// leftsinglequotemark
	case 0x2019: return 0x0ad1;		// rightsinglequotemark
	case 0x201A: return 0x0afd;		// singlelowquotemark
	case 0x201C: return 0x0ad2;		// leftdoublequotemark
	case 0x201D: return 0x0ad3;		// rightdoublequotemark
	case 0x201E: return 0x0afe;		// doublelowquotemark
	case 0x2020: return 0x0af1;		// dagger
	case 0x2021: return 0x0af2;		// doubledagger
	case 0x2022: return 0x0ae6;		// enfilledcircbullet
	case 0x2025: return 0x0aaf;		// doubbaselinedot
	case 0x2026: return 0x0aae;		// ellipsis
	case 0x2030: return 0x0ad5;		// permille
	case 0x2032: return 0x0ad6;		// minutes
	case 0x2033: return 0x0ad7;		// seconds
	case 0x2038: return 0x0afc;		// caret
	case 0x203E: return 0x047e;		// overline
	case 0x20A9: return 0x0eff;		// Korean_Won
	case 0x20AC: return 0x20ac;		// EuroSign
	case 0x2105: return 0x0ab8;		// careof
	case 0x2116: return 0x06b0;		// numerosign
	case 0x2117: return 0x0afb;		// phonographcopyright
	case 0x211E: return 0x0ad4;		// prescription
	case 0x2122: return 0x0ac9;		// trademark
	case 0x2153: return 0x0ab0;		// onethird
	case 0x2154: return 0x0ab1;		// twothirds
	case 0x2155: return 0x0ab2;		// onefifth
	case 0x2156: return 0x0ab3;		// twofifths
	case 0x2157: return 0x0ab4;		// threefifths
	case 0x2158: return 0x0ab5;		// fourfifths
	case 0x2159: return 0x0ab6;		// onesixth
	case 0x215A: return 0x0ab7;		// fivesixths
	case 0x215B: return 0x0ac3;		// oneeighth
	case 0x215C: return 0x0ac4;		// threeeighths
	case 0x215D: return 0x0ac5;		// fiveeighths
	case 0x215E: return 0x0ac6;		// seveneighths
	case 0x2190: return 0x08fb;		// leftarrow
	case 0x2191: return 0x08fc;		// uparrow
	case 0x2192: return 0x08fd;		// rightarrow
	case 0x2193: return 0x08fe;		// downarrow
	case 0x21D2: return 0x08ce;		// implies
	case 0x21D4: return 0x08cd;		// ifonlyif
	case 0x2202: return 0x08ef;		// partialderivative
	case 0x2207: return 0x08c5;		// nabla
	case 0x2218: return 0x0bca;		// jot
	case 0x221A: return 0x08d6;		// radical
	case 0x221D: return 0x08c1;		// variation
	case 0x221E: return 0x08c2;		// infinity
	case 0x2227: return 0x08de;		// logicaland
	case 0x2228: return 0x08df;		// logicalor
	case 0x2229: return 0x08dc;		// intersection
	case 0x222A: return 0x08dd;		// union
	case 0x222B: return 0x08bf;		// integral
	case 0x2234: return 0x08c0;		// therefore
	case 0x223C: return 0x08c8;		// approximate
	case 0x2243: return 0x08c9;		// similarequal
	case 0x2260: return 0x08bd;		// notequal
	case 0x2261: return 0x08cf;		// identical
	case 0x2264: return 0x08bc;		// lessthanequal
	case 0x2265: return 0x08be;		// greaterthanequal
	case 0x2282: return 0x08da;		// includedin
	case 0x2283: return 0x08db;		// includes
	case 0x22A2: return 0x0bfc;		// righttack
	case 0x22A3: return 0x0bdc;		// lefttack
	case 0x22A4: return 0x0bc2;		// downtack
	case 0x22A5: return 0x0bce;		// uptack
	case 0x2308: return 0x0bd3;		// upstile
	case 0x230A: return 0x0bc4;		// downstile
	case 0x2315: return 0x0afa;		// telephonerecorder
	case 0x2320: return 0x08a4;		// topintegral
	case 0x2321: return 0x08a5;		// botintegral
	case 0x2395: return 0x0bcc;		// quad
	case 0x239B: return 0x08ab;		// topleftparens
	case 0x239D: return 0x08ac;		// botleftparens
	case 0x239E: return 0x08ad;		// toprightparens
	case 0x23A0: return 0x08ae;		// botrightparens
	case 0x23A1: return 0x08a7;		// topleftsqbracket
	case 0x23A3: return 0x08a8;		// botleftsqbracket
	case 0x23A4: return 0x08a9;		// toprightsqbracket
	case 0x23A6: return 0x08aa;		// botrightsqbracket
	case 0x23A8: return 0x08af;		// leftmiddlecurlybrace
	case 0x23AC: return 0x08b0;		// rightmiddlecurlybrace
	case 0x23B7: return 0x08a1;		// leftradical
	case 0x23BA: return 0x09ef;		// horizlinescan1
	case 0x23BB: return 0x09f0;		// horizlinescan3
	case 0x23BC: return 0x09f2;		// horizlinescan7
	case 0x23BD: return 0x09f3;		// horizlinescan9
	case 0x2409: return 0x09e2;		// ht
	case 0x240A: return 0x09e5;		// lf
	case 0x240B: return 0x09e9;		// vt
	case 0x240C: return 0x09e3;		// ff
	case 0x240D: return 0x09e4;		// cr
	case 0x2423: return 0x0aac;		// signifblank
	case 0x2424: return 0x09e8;		// nl
	case 0x2500: return 0x09f1;		// horizlinescan5
	case 0x2502: return 0x09f8;		// vertbar
	case 0x250C: return 0x09ec;		// upleftcorner
	case 0x2510: return 0x09eb;		// uprightcorner
	case 0x2514: return 0x09ed;		// lowleftcorner
	case 0x2518: return 0x09ea;		// lowrightcorner
	case 0x251C: return 0x09f4;		// leftt
	case 0x2524: return 0x09f5;		// rightt
	case 0x252C: return 0x09f7;		// topt
	case 0x2534: return 0x09f6;		// bott
	case 0x253C: return 0x09ee;		// crossinglines
	case 0x2592: return 0x09e1;		// checkerboard
	case 0x25AA: return 0x0ae7;		// enfilledsqbullet
	case 0x25AB: return 0x0ae1;		// enopensquarebullet
	case 0x25AC: return 0x0adb;		// filledrectbullet
	case 0x25AD: return 0x0ae2;		// openrectbullet
	case 0x25AE: return 0x0adf;		// emfilledrect
	case 0x25AF: return 0x0acf;		// emopenrectangle
	case 0x25B2: return 0x0ae8;		// filledtribulletup
	case 0x25B3: return 0x0ae3;		// opentribulletup
	case 0x25B6: return 0x0add;		// filledrighttribullet
	case 0x25B7: return 0x0acd;		// rightopentriangle
	case 0x25BC: return 0x0ae9;		// filledtribulletdown
	case 0x25BD: return 0x0ae4;		// opentribulletdown
	case 0x25C0: return 0x0adc;		// filledlefttribullet
	case 0x25C1: return 0x0acc;		// leftopentriangle
	case 0x25C6: return 0x09e0;		// soliddiamond
	case 0x25CB: return 0x0bcf;		// circle
	case 0x25CF: return 0x0ade;		// emfilledcircle
	case 0x25E6: return 0x0ae0;		// enopencircbullet
	case 0x2606: return 0x0ae5;		// openstar
	case 0x260E: return 0x0af9;		// telephone
	case 0x2613: return 0x0aca;		// signaturemark
	case 0x261C: return 0x0aea;		// leftpointer
	case 0x261E: return 0x0aeb;		// rightpointer
	case 0x2640: return 0x0af8;		// femalesymbol
	case 0x2642: return 0x0af7;		// malesymbol
	case 0x2663: return 0x0aec;		// club
	case 0x2665: return 0x0aee;		// heart
	case 0x2666: return 0x0aed;		// diamond
	case 0x266D: return 0x0af6;		// musicalflat
	case 0x266F: return 0x0af5;		// musicalsharp
	case 0x2713: return 0x0af3;		// checkmark
	case 0x2717: return 0x0af4;		// ballotcross
	case 0x271D: return 0x0ad9;		// latincross
	case 0x2720: return 0x0af0;		// maltesecross
	case 0x27E8: return 0x0abc;		// leftanglebracket
	case 0x27E9: return 0x0abe;		// rightanglebracket
	case 0x3001: return 0x04a4;		// kana_comma
	case 0x3002: return 0x04a1;		// kana_fullstop
	case 0x300C: return 0x04a2;		// kana_openingbracket
	case 0x300D: return 0x04a3;		// kana_closingbracket
	case 0x309B: return 0x04de;		// voicedsound
	case 0x309C: return 0x04df;		// semivoicedsound
	case 0x30A1: return 0x04a7;		// kana_a
	case 0x30A2: return 0x04b1;		// kana_A
	case 0x30A3: return 0x04a8;		// kana_i
	case 0x30A4: return 0x04b2;		// kana_I
	case 0x30A5: return 0x04a9;		// kana_u
	case 0x30A6: return 0x04b3;		// kana_U
	case 0x30A7: return 0x04aa;		// kana_e
	case 0x30A8: return 0x04b4;		// kana_E
	case 0x30A9: return 0x04ab;		// kana_o
	case 0x30AA: return 0x04b5;		// kana_O
	case 0x30AB: return 0x04b6;		// kana_KA
	case 0x30AD: return 0x04b7;		// kana_KI
	case 0x30AF: return 0x04b8;		// kana_KU
	case 0x30B1: return 0x04b9;		// kana_KE
	case 0x30B3: return 0x04ba;		// kana_KO
	case 0x30B5: return 0x04bb;		// kana_SA
	case 0x30B7: return 0x04bc;		// kana_SHI
	case 0x30B9: return 0x04bd;		// kana_SU
	case 0x30BB: return 0x04be;		// kana_SE
	case 0x30BD: return 0x04bf;		// kana_SO
	case 0x30BF: return 0x04c0;		// kana_TA
	case 0x30C1: return 0x04c1;		// kana_CHI
	case 0x30C3: return 0x04af;		// kana_tsu
	case 0x30C4: return 0x04c2;		// kana_TSU
	case 0x30C6: return 0x04c3;		// kana_TE
	case 0x30C8: return 0x04c4;		// kana_TO
	case 0x30CA: return 0x04c5;		// kana_NA
	case 0x30CB: return 0x04c6;		// kana_NI
	case 0x30CC: return 0x04c7;		// kana_NU
	case 0x30CD: return 0x04c8;		// kana_NE
	case 0x30CE: return 0x04c9;		// kana_NO
	case 0x30CF: return 0x04ca;		// kana_HA
	case 0x30D2: return 0x04cb;		// kana_HI
	case 0x30D5: return 0x04cc;		// kana_FU
	case 0x30D8: return 0x04cd;		// kana_HE
	case 0x30DB: return 0x04ce;		// kana_HO
	case 0x30DE: return 0x04cf;		// kana_MA
	case 0x30DF: return 0x04d0;		// kana_MI
	case 0x30E0: return 0x04d1;		// kana_MU
	case 0x30E1: return 0x04d2;		// kana_ME
	case 0x30E2: return 0x04d3;		// kana_MO
	case 0x30E3: return 0x04ac;		// kana_ya
	case 0x30E4: return 0x04d4;		// kana_YA
	case 0x30E5: return 0x04ad;		// kana_yu
	case 0x30E6: return 0x04d5;		// kana_YU
	case 0x30E7: return 0x04ae;		// kana_yo
	case 0x30E8: return 0x04d6;		// kana_YO
	case 0x30E9: return 0x04d7;		// kana_RA
	case 0x30EA: return 0x04d8;		// kana_RI
	case 0x30EB: return 0x04d9;		// kana_RU
	case 0x30EC: return 0x04da;		// kana_RE
	case 0x30ED: return 0x04db;		// kana_RO
	case 0x30EF: return 0x04dc;		// kana_WA
	case 0x30F2: return 0x04a6;		// kana_WO
	case 0x30F3: return 0x04dd;		// kana_N
	case 0x30FB: return 0x04a5;		// kana_conjunctive
	case 0x30FC: return 0x04b0;		// prolongedsound
	default: return NoSymbol;
  };
}
",16348,True,4461.977704707686,median
"/*******************************************************************************
* Copyright 2017 Intel Corporation
*
* Licensed under the Apache License, Version 2.0 (the ""License"");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an ""AS IS"" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/

#include ""c_types_map.hpp""
#include ""mkldnn_thread.hpp""
#include ""nstl.hpp""
#include ""type_helpers.hpp""
#include ""utils.hpp""

#include <math.h>

#include ""jit_avx512_common_conv_winograd_kernel_f32.hpp""

#ifndef KERNEL_SIZE_THRESHOLD
#define KERNEL_SIZE_THRESHOLD 16
#endif

#define MIN_REQUIRED_DIMN_REG_BLOCK 14

namespace mkldnn {
namespace impl {
namespace cpu {

namespace {

using namespace mkldnn::impl::utils;

unsigned int L1_cache_size = get_cache_size(1, true);
unsigned int L2_cache_size = get_cache_size(2, true);
unsigned int LLC_data_size = get_cache_size(3, false);

// the test funtion takes jcp, the candidate and the current best.
// it  returns true if the new candidate is better
int get_divisor_satisfying_cond(jit_conv_winograd_conf_t &jcp, int number,
        int default_best, bool (*test)(jit_conv_winograd_conf_t &, int, int))
{
    int best_divisor = default_best;
    auto test_num
            = [&best_divisor, test](jit_conv_winograd_conf_t &jcp, int num) {
                  if (test(jcp, num, best_divisor)) {
                      best_divisor = num;
                  }
              };

    for (int divisor = 1; divisor <= ::sqrt(number); divisor++) {
        if (number % divisor == 0) {
            test_num(jcp, divisor);
            test_num(jcp, number / divisor);
        }
    }

    return best_divisor;
}

/* assumes 512 bits registers */
/* TODO: add support for strides */
/* TODO: handle the prefetch distance automatically */
typedef enum cache_t_ { L1, L2, L3 } cache_t;

template <typename data_t>
struct prefetcher_t {
    prefetcher_t(jit_generator *generator, Xbyak::Reg64 reg_base_addr,
            cache_t cache_type, size_t block_size, /* in number of elements*/
            int nb_instructions_in_block, int fma_ipc)
        : cg_(generator)
        , reg_base_addr_(reg_base_addr)
        , cache_type_(cache_type)
        , cache_block_size_(block_size)
    {
        nb_cache_lines_to_prefetch_ = cache_block_size_ / (64 / sizeof(data_t));
        prefetch_spread_
                = div_up(nb_instructions_in_block, nb_cache_lines_to_prefetch_);
        prefetch_blk_
                = div_up(nb_cache_lines_to_prefetch_, nb_instructions_in_block);

        /* assumption: when fetch in Li, data is already in L(i+1) */
        int cache_latency;
        switch (cache_type_) {
        case L1: cache_latency = 14; break;
        case L2: cache_latency = 250; break;
        case L3: cache_latency = 250; break;
        }

        prefetch_distance_ = div_up(cache_latency, nb_cache_lines_to_prefetch_);
    }

    void prefetch(int instruction_number)
    {
        if (instruction_number % prefetch_spread_ == 0) {
            for (int i = 0; (i < prefetch_blk_)
                    && (prefetches_issued_ < nb_cache_lines_to_prefetch_);
                    i++, prefetches_issued_++) {
                prefetch_inst_(cg_->EVEX_compress_addr(
                        reg_base_addr_, (cache_block_size_ * prefetch_distance_)
                                        * sizeof(data_t)
                                + (prefetches_issued_ * 64)));
            }
        }
    }

private:
    void prefetch_inst_(const Xbyak::Address &addr)
    {
        switch (cache_type_) {
        case L1: cg_->prefetcht0(addr); break;
        case L2: cg_->prefetcht1(addr); break;
        case L3: cg_->prefetcht2(addr); break;
        default:
            break; // TODO: raise an exception or put an assert
        }
    }

    jit_generator *cg_;
    Xbyak::Reg64 reg_base_addr_;
    cache_t cache_type_;
    int cache_block_size_ = 0;
    int nb_cache_lines_to_prefetch_ = 0;
    int prefetches_issued_ = 0;
    int prefetch_spread_ = 0;
    int prefetch_blk_ = 0;
    int prefetch_distance_ = 0;
};

// utilities to support kernel parameter selection
bool check_L2_block_per_thread(jit_conv_winograd_conf_t &jcp,
        int dimN_block, float C2_min, float C2_max) {
    /* V_L2_block + M_L2_block + W */
    float block_size = (jcp.alpha * jcp.alpha * (jcp.oc + jcp.ic)
                     * dimN_block * jcp.dimN_reg_block
                     + jcp.ic * jcp.oc) * (float)sizeof(float);
    float L2_lb = C2_min * L2_cache_size;
    float L2_ub =  C2_max * L2_cache_size;
    return (block_size > L2_lb && block_size < L2_ub);
}

bool check_L1_block_gemm(jit_conv_winograd_conf_t &jcp, int dimK_block,
        int dimM_block, float C1_min, float C1_max) {
    float gemm_block_size = (dimM_block * jcp.dimM_simd_block * dimK_block
                             * jcp.dimK_reg_block
                     + dimK_block * jcp.dimK_reg_block * jcp.dimN_reg_block
                     + dimM_block * jcp.dimM_simd_block * jcp.dimN_reg_block)
                     * (float)sizeof(float);
    float L1_lb = C1_min * L1_cache_size;
    float L1_ub = C1_max * L1_cache_size;
    return (gemm_block_size > L1_lb && gemm_block_size < L1_ub);
}

bool check_cond1(int dimN_reg_block, int dimK_block, int dimK_reg_block,
        int dimM_block, int dimM_simd_block, float C)
{
    float lhs = (dimM_block * dimN_reg_block * dimM_simd_block
                        + dimM_block * dimK_block * dimK_reg_block
                                * dimM_simd_block
                        + dimK_block * dimN_reg_block * dimK_reg_block)
            * (float)sizeof(float);
    float rhs = C * L1_cache_size;
    return (lhs < rhs);
}

bool check_cond1_bis(int dimN_reg_block, int dimK_block, int dimK_reg_block,
        int dimM_block, int dimM_simd_block, float C)
{
    float lhs = (dimM_block * dimK_block * dimK_reg_block * dimM_simd_block
                        + dimK_block * dimN_reg_block * dimK_reg_block)
            * (float)sizeof(float);
    float rhs = C * L1_cache_size;
    return (lhs < rhs);
}

bool check_cond2(int nb_dimN_reg_block, int dimN_reg_block, int dimK_nb_block,
        int dimK_block, int dimK_reg_block, int dimM_block, int dimM_simd_block,
        float C)
{
    float lhs = (nb_dimN_reg_block * dimM_block * dimN_reg_block * dimM_simd_block
                      + dimK_nb_block * dimM_block * dimK_block * dimK_reg_block
                              * dimM_simd_block
                      + nb_dimN_reg_block * dimK_nb_block * dimK_block
                              * dimN_reg_block * dimK_reg_block)
            * (float)sizeof(float);
    float rhs = C * L2_cache_size;
    return (lhs < rhs);
}
}

using namespace mkldnn::impl::memory_format;
using namespace mkldnn::impl::utils;
using namespace Xbyak;

void _jit_avx512_common_conv_winograd_data_kernel_f32::gemm_loop_generate(
        bool is_beta_zero)
{
    // const int dimK_simd_block = jcp.dimK_reg_block;

    // for (int dimM_block =0; dimM_block < jcp.dimM_block; dimM_block++)
    //     for (int dimK_block = 0; dimK_block < jcp.dimK_block; dimK_block++)
    //         for (int dimK_reg_block= 0; dimK_reg_block < jcp.dimK_reg_block;
    //         dimK_reg_block++)
    //                 for (int tile =0; tile < jcp.dimN_reg_block; tile++)
    //                     C[dimM_block][tile] +=
    //                     A[dimM_block][dimK_block][dimK_reg_block] *
    //                     broadcast(B[dimK_block][tile][dimK_reg_block]);
    // 1) We do register blocking on A[dimM_block][dimK_block][dimK_reg_block],
    // so we load it before the loop on tile
    // 2) the loop on tile must be fully unrolled. Don't know about the one on
    // dimK_reg_block. I think it should be

    auto inner_loops = [=]() {
        Label dimM_block_loop, dimK_block_loop;
        const int inc_dimK_reg_block = jcp.ver == ver_4fma ? 4 : 1;
        const int fma_ipc = jcp.ver == ver_4fma ? 1 : 2;

        prefetcher_t<float> L1_pf(this, reg_srcB, L1,
                jcp.dimN_reg_block * jcp.dimK_reg_block,
                jcp.dimK_reg_block * jcp.dimN_reg_block / inc_dimK_reg_block,
                fma_ipc);
        prefetcher_t<float> L2_pf(this, reg_srcB, L2,
                jcp.dimN_reg_block * jcp.dimK_reg_block,
                jcp.dimK_reg_block * jcp.dimN_reg_block / inc_dimK_reg_block,
                fma_ipc);

        if (jcp.dimM_block > 1) {
            mov(reg_dimM_block_loop_cnt, jcp.dimM_block);
            L(dimM_block_loop);
        }
        {
            // First, we zero the accumulators if first nb_ic iteration,
            // otherwise we load them
            for (int tile = 0; tile < jcp.dimN_reg_block; tile++) {
                Zmm zmm(jcp.zmm_start + tile);
                if (is_beta_zero)
                    vpxord(zmm, zmm, zmm);
                else
                    vmovups(zmm, zword[reg_dstC + 64 * tile]);
            }

            if (jcp.dimK_block > 1) {
                mov(reg_dimK_block_loop_cnt, jcp.dimK_block);
                L(dimK_block_loop);
            }
            {
                auto load_A = [=](int reg_idx, int offset) {
                    for (int i = 0; i < inc_dimK_reg_block; i++)
                        vmovups(Zmm(reg_idx + i),
                                zword[reg_srcA + 64 * (offset + i)]);
                };

                // Used when doing double buffering
                int next = 0;
                if (jcp.double_buffering) {
                    load_A(next, 0);
                }
                for (int dimK_reg_block = 0;
                        dimK_reg_block < jcp.dimK_reg_block;
                        dimK_reg_block += inc_dimK_reg_block) {
                    int current;
                    /* Loading the next vector from A */
                    current = next;
                    if (jcp.double_buffering) {
                        next = (dimK_reg_block + inc_dimK_reg_block)
                                % (2 * inc_dimK_reg_block);
                        load_A(next, dimK_reg_block + inc_dimK_reg_block);
                    } else {
                        next = 0;
                        load_A(next, dimK_reg_block);
                    }
                    /* Performing the fmas */
                    for (int tile = 0; tile < jcp.dimN_reg_block; tile++) {
                        Zmm zmm(jcp.zmm_start + tile);
                        if (jcp.ver != ver_avx512_core)
                            L1_pf.prefetch(
                                    dimK_reg_block * jcp.dimN_reg_block + tile);
                        if (jcp.ver == ver_4fma)
                            v4fmaddps(zmm, Zmm(current),
                                    EVEX_compress_addr(reg_srcB,
                                              64 * tile + dimK_reg_block * 4));
                        else
                            vfmadd231ps(zmm, Zmm(current),
                                    EVEX_compress_addr(reg_srcB,
                                                64 * tile + dimK_reg_block * 4,
                                                true));
                        if (jcp.ver != ver_avx512_core)
                            L2_pf.prefetch(
                                    dimK_reg_block * jcp.dimN_reg_block + tile);
                    }
                }

                add(reg_srcA, jcp.dimK_reg_block * 64);
                add(reg_srcB, jcp.dimN_reg_block * 64);
                if (jcp.dimK_block > 1) {
                    sub(reg_dimK_block_loop_cnt, 1);
                    jnz(dimK_block_loop);
                }
            }

            for (int tile = 0; tile < jcp.dimN_reg_block; tile++) {
                Zmm zmm(jcp.zmm_start + tile);
                // In W_SGD, output will be reused.
                if (jcp.dimK_nb_block == 1
                    && jcp.sched_policy == WSCHED_DATA_W_S_G_D
                    && (jcp.dimN * jcp.dimM * jcp.alpha * jcp.alpha
                        * sizeof(float) > 2 * LLC_data_size))
                    vmovntps(zword[reg_dstC + 64 * tile], zmm);
                else
                    vmovups(zword[reg_dstC + 64 * tile], zmm);
            }

            if (jcp.dimM_block > 1) {
                sub(reg_srcB, jcp.dimK_block * jcp.dimN_reg_block * 64);
                add(reg_dstC, jcp.dimN_reg_block * 64);
                sub(reg_dimM_block_loop_cnt, 1);
                jnz(dimM_block_loop);
            }
        }
    };

    /* Preamble */
    // register used to handle long fma encoding
    push(reg_EVEX_max_8b_offt);
    mov(reg_EVEX_max_8b_offt, 2 * EVEX_max_8b_offt);

    /* kernel */
    inner_loops();

    /* Postamble */
    pop(reg_EVEX_max_8b_offt);
    ret();
}

status_t _jit_avx512_common_conv_winograd_data_kernel_f32::init_conf_common(
        jit_conv_winograd_conf_t &jcp, const convolution_desc_t &cd,
        const memory_desc_wrapper &src_d, const memory_desc_wrapper &weights_d,
        const memory_desc_wrapper &dst_d)
{

    if (!mayiuse(avx512_common))
        return status::unimplemented;
    else if (mayiuse(avx512_core))
        jcp.ver = ver_avx512_core;
    else if (mayiuse(avx512_mic_4ops))
        jcp.ver = ver_4fma;
    else
        jcp.ver = ver_fma;

    const bool with_groups = weights_d.ndims() == src_d.ndims() + 1;
    const int simd_w = 16;

    jcp.ngroups = with_groups ? weights_d.dims()[0] : 1;
    jcp.mb = src_d.dims()[0];
    jcp.oc = dst_d.dims()[1] / jcp.ngroups;
    jcp.ic = src_d.dims()[1] / jcp.ngroups;
    jcp.ih = src_d.dims()[2];
    jcp.iw = src_d.dims()[3];
    jcp.oh = dst_d.dims()[2];
    jcp.ow = dst_d.dims()[3];
    jcp.kh = weights_d.dims()[with_groups + 2];
    jcp.kw = weights_d.dims()[with_groups + 3];
    jcp.t_pad = cd.padding[0][0];
    jcp.l_pad = cd.padding[0][1];
    jcp.stride_h = cd.strides[0];
    jcp.stride_w = cd.strides[1];
    jcp.dilate_h = cd.dilates[0];
    jcp.dilate_w = cd.dilates[1];
    jcp.r_pad = nstl::max(
            0, (jcp.ow - 1) * jcp.stride_w + jcp.kw - jcp.iw - jcp.l_pad);
    jcp.b_pad = nstl::max(
            0, (jcp.oh - 1) * jcp.stride_h + jcp.kh - jcp.ih - jcp.t_pad);
    jcp.ihp = jcp.ih + jcp.t_pad + jcp.b_pad;
    jcp.iwp = jcp.iw + jcp.l_pad + jcp.r_pad;
    jcp.ohp = jcp.oh;
    jcp.owp = jcp.ow;

    // Checking conditions not supported by these kernels
    if (jcp.ngroups != 1)
        return status::unimplemented;
    if ((jcp.kh != 3) || (jcp.kw != 3))
        return status::unimplemented;
    if ((jcp.dilate_h != 0) || (jcp.dilate_w != 0))
        return status::unimplemented;
    if ((jcp.stride_h != 1) || (jcp.stride_w != 1))
        return status::unimplemented;
    if ((jcp.ic % simd_w) != 0 || (jcp.oc % simd_w) != 0)
        return status::unimplemented;

    if (src_d.format() != nChw16c)
        return status::unimplemented;
    if (weights_d.format() != (with_groups ? gOIhw16i16o : OIhw16i16o))
        return status::unimplemented;
    if (dst_d.format() != nChw16c)
        return status::unimplemented;


    return status::success;
}

status_t set_wsched_DATA_W_SGD(jit_conv_winograd_conf_t &jcp) {

    if (jcp.ver != ver_avx512_core)
        return status::unimplemented;

    /* ----------- dimN reg block ---------------------*/
    auto test_cond_dimN_reg_block = [](jit_conv_winograd_conf_t &jcp,
            int dimN_reg_block, int current_best) {
        return (dimN_reg_block >= MIN_REQUIRED_DIMN_REG_BLOCK)
            && (dimN_reg_block <= jcp.nb_reg)
            && (dimN_reg_block < current_best);
    };

    jcp.dimN_reg_block = get_divisor_satisfying_cond(
            jcp, jcp.dimN, jcp.dimN, test_cond_dimN_reg_block);

    if (jcp.dimN_reg_block >= jcp.nb_reg) {
        auto test_cond_dimN_reg_block = [](jit_conv_winograd_conf_t &jcp,
                int dimN_reg_block, int current_best) {
            return (dimN_reg_block < jcp.nb_reg)
                    && (dimN_reg_block > current_best);
        };

        jcp.dimN_reg_block = get_divisor_satisfying_cond(
                jcp, jcp.dimN, 1, test_cond_dimN_reg_block);
    }

    /*-------------- L2 blocking for dimN block ---------*/

    auto test_cond_dimN_block = [](jit_conv_winograd_conf_t &jcp,
            int dimN_block, int current_best) {
        return check_L2_block_per_thread(jcp, dimN_block, 0.1, 1.3)
            && (dimN_block > current_best)
            && ((jcp.dimN / dimN_block / jcp.dimN_reg_block) > 2 * omp_get_max_threads());
    };

    jcp.dimN_block = get_divisor_satisfying_cond(
            jcp, jcp.dimN / jcp.dimN_reg_block, 1, test_cond_dimN_block);

    if (check_L2_block_per_thread(jcp, jcp.dimN_block, 0.1, 1.3)
        && jcp.dimN/ jcp.dimN_block/ jcp.dimN_reg_block > 2 * omp_get_max_threads()) {
        jcp.dimN_nb_block = jcp.dimN / jcp.dimN_block / jcp.dimN_reg_block;

        /* ------------------- L1 blocking for GEMM --------------*/
        /* -------------------- Choose dimK block ----------------*/
        auto test_cond_dimK_block = [](jit_conv_winograd_conf_t &jcp,
                int dimK_block, int current_best) {
            return check_L1_block_gemm(jcp, dimK_block, 1, 0.1, 0.6)
                && (dimK_block > current_best);
        };

        jcp.dimK_block = get_divisor_satisfying_cond(
                jcp, jcp.dimK / jcp.dimK_reg_block, 1, test_cond_dimK_block);

        if (check_L1_block_gemm(jcp, jcp.dimK_block, 1, 0.1, 0.6)) {
            jcp.dimK_nb_block = jcp.dimK / jcp.dimK_block / jcp.dimK_reg_block;

            /* -------------- Choose dimM block -------------------*/
            auto test_cond_dimM_block = [](jit_conv_winograd_conf_t &jcp,
                    int dimM_block, int current_best) {
                return check_L1_block_gemm(jcp, jcp.dimK_block, dimM_block, 0.1, 0.7)
                    && (dimM_block > current_best);
            };

            jcp.dimM_block = get_divisor_satisfying_cond(
                    jcp, jcp.dimM / jcp.dimM_simd_block, 1, test_cond_dimM_block);
            jcp.dimM_nb_block = jcp.dimM / jcp.dimM_block / jcp.dimM_simd_block;

            jcp.sched_policy = WSCHED_DATA_W_SGD;
            return status::success;
        }

    }
    return status::unimplemented;

}


status_t set_wsched_DATA_W_S_G_D(jit_conv_winograd_conf_t &jcp) {

    auto test_cond_dimN_reg_block = [](jit_conv_winograd_conf_t &jcp,
            int dimN_reg_block, int current_best) {
        return (dimN_reg_block >= MIN_REQUIRED_DIMN_REG_BLOCK)
                && (dimN_reg_block < jcp.nb_reg)
                && (dimN_reg_block < current_best);
    };
    jcp.dimN_reg_block = get_divisor_satisfying_cond(
            jcp, jcp.dimN, jcp.dimN, test_cond_dimN_reg_block);

    if (jcp.dimN_reg_block >= jcp.nb_reg) {
        auto test_cond_dimN_reg_block = [](jit_conv_winograd_conf_t &jcp,
                int dimN_reg_block, int current_best) {
            return (dimN_reg_block < jcp.nb_reg)
                    && (dimN_reg_block > current_best);
        };

        jcp.dimN_reg_block = get_divisor_satisfying_cond(
                jcp, jcp.dimN, 1, test_cond_dimN_reg_block);
    }

    //********************* Choosing dimK_block **********************//
    auto test_cond1_dimK_block = [](
            jit_conv_winograd_conf_t &jcp, int dimK_block, int current_best) {
        return check_cond1(jcp.dimN_reg_block, dimK_block, jcp.dimK_reg_block,
                       1, jcp.dimM_simd_block, .75f)
                && (dimK_block > current_best);
    };

    auto test_cond1_bis_dimK_block = [](
            jit_conv_winograd_conf_t &jcp, int dimK_block, int current_best) {
        return check_cond1_bis(jcp.dimN_reg_block, dimK_block,
                       jcp.dimK_reg_block, 1, jcp.dimM_simd_block, .9f)
                && (dimK_block > current_best);
    };

    jcp.dimK_block = get_divisor_satisfying_cond(
            jcp, jcp.dimK / jcp.dimK_reg_block, 1, test_cond1_bis_dimK_block);
    // If we are not able to use streams, we fall back to condition [1]
    if (jcp.dimK_block < jcp.dimK / jcp.dimK_reg_block)
        jcp.dimK_block = get_divisor_satisfying_cond(
                jcp, jcp.dimK / jcp.dimK_reg_block, 1, test_cond1_dimK_block);
    jcp.dimK_nb_block = (jcp.dimK / jcp.dimK_reg_block) / jcp.dimK_block;

    //********************* Choosing dimM_block **********************//
    jcp.dimM_simd_block = 16;
    /*XXX: Why C=0.5 here but C=0.75 for dimK_block?*/
    auto test_cond1_dimM_block = [](
            jit_conv_winograd_conf_t &jcp, int dimM_block, int current_best) {
        return check_cond1(jcp.dimN_reg_block, jcp.dimK_block,
                       jcp.dimK_reg_block, dimM_block, jcp.dimM_simd_block, .5f)
                && (dimM_block > current_best);
    };

    auto test_cond1_bis_dimM_block = [](
            jit_conv_winograd_conf_t &jcp, int dimM_block, int current_best) {
        return check_cond1_bis(jcp.dimN_reg_block, jcp.dimK_block,
                       jcp.dimK_reg_block, dimM_block, jcp.dimM_simd_block, .3f)
                && (dimM_block > current_best);
    };

    if (jcp.dimK_block < jcp.dimK / jcp.dimK_reg_block)
        jcp.dimM_block = get_divisor_satisfying_cond(
                jcp, jcp.dimM / jcp.dimM_simd_block, 1, test_cond1_dimM_block);
    else
        jcp.dimM_block = get_divisor_satisfying_cond(jcp,
                jcp.dimM / jcp.dimM_simd_block, 1, test_cond1_bis_dimM_block);
    jcp.dimM_nb_block = (jcp.dimM / jcp.dimM_simd_block) / jcp.dimM_block;

    //******************* Choosing dimN_block *******************//
    auto test_cond2_dimN_block = [](
            jit_conv_winograd_conf_t &jcp, int dimN_block, int current_best) {
        return check_cond2(dimN_block, jcp.dimN_reg_block, jcp.dimK_nb_block,
                       jcp.dimK_block, jcp.dimK_reg_block, jcp.dimM_block,
                       jcp.dimM_simd_block, .5f)
                && (dimN_block > current_best);
    };

    jcp.dimN_block = get_divisor_satisfying_cond(
            jcp, jcp.dimN / jcp.dimN_reg_block, 1, test_cond2_dimN_block);
    jcp.dimN_nb_block = jcp.dimN / (jcp.dimN_reg_block * jcp.dimN_block);
    jcp.sched_policy = WSCHED_DATA_W_S_G_D;
    return status::success;
    //return status::unimplemented;
}

status_t _jit_avx512_common_conv_winograd_data_kernel_f32::init_conf_kernel(
        jit_conv_winograd_conf_t &jcp, int dimM, int dimN, int dimK)
{
    jcp.dimK_reg_block = 16;
    jcp.dimM_simd_block = 16;

    // TODO: replace double buffering with nuple buffering to maximize register
    // usage.
    // the choice of the number of buffers will then come after choosing
    // dimN_reg_block
    jcp.double_buffering = true;
    if (jcp.double_buffering)
        jcp.zmm_start = 2 * ((jcp.ver == ver_4fma) ? 4 : 2);
    else
        jcp.zmm_start = 1;
    jcp.nb_reg = 32 - jcp.zmm_start;

    jcp.dimN = dimN;
    jcp.dimK = dimK;
    jcp.dimM = dimM;

    jcp.sched_policy = WSCHED_INVALID;
    if (!(set_wsched_DATA_W_SGD(jcp) == status::success))
        set_wsched_DATA_W_S_G_D(jcp);

    assert(jcp.sched_policy != WSCHED_INVALID);
    return status::success;
}

status_t jit_avx512_common_conv_winograd_fwd_kernel_f32::init_conf(
        jit_conv_winograd_conf_t &jcp, const convolution_desc_t &cd,
        const memory_desc_wrapper &src_d, const memory_desc_wrapper &weights_d,
        const memory_desc_wrapper &dst_d, bool with_relu,
        float relu_negative_slope)
{
    status_t st = init_conf_common(jcp, cd, src_d, weights_d, dst_d);

    if (st != status::success)
        return st;

    // Winograd specific initialization
    const int tile_size = jcp.alpha - 2;
    jcp.itiles = (jcp.ow + tile_size - 1) / tile_size;
    jcp.jtiles = (jcp.oh + tile_size - 1) / tile_size;
    jcp.ntiles = jcp.mb * jcp.itiles * jcp.jtiles;

    jcp.with_bias = cd.bias_desc.format != memory_format::undef;
    jcp.with_relu = with_relu;
    jcp.relu_negative_slope = relu_negative_slope;

    status_t res = init_conf_kernel(jcp, jcp.oc, jcp.ntiles, jcp.ic);
    jcp.ic_simd_block = jcp.dimK_reg_block;
    jcp.ic_block = jcp.dimK_block;
    jcp.nb_ic = jcp.dimK_nb_block;
    jcp.oc_simd_block = jcp.dimM_simd_block;
    jcp.oc_block = jcp.dimM_block;
    jcp.nb_oc = jcp.dimM_nb_block;
    jcp.tile_block_ur = jcp.dimN_reg_block;
    jcp.nb_tile_block_ur = jcp.dimN_block;
    jcp.tile_block = jcp.dimN_nb_block;
    jcp.tile_4fma_padding = 0; // only relevant for backward weights

    return res;
}

status_t jit_avx512_common_conv_winograd_bwd_data_kernel_f32::init_conf(
        jit_conv_winograd_conf_t &jcp, const convolution_desc_t &cd,
        const memory_desc_wrapper &diff_src_d,
        const memory_desc_wrapper &weights_d,
        const memory_desc_wrapper &diff_dst_d)
{
    status_t st = init_conf_common(jcp, cd, diff_src_d, weights_d, diff_dst_d);

    if (st != status::success)
        return st;

    const int tile_size = jcp.alpha - 2;
    jcp.itiles = (jcp.iw + tile_size - 1) / tile_size;
    jcp.jtiles = (jcp.ih + tile_size - 1) / tile_size;
    jcp.ntiles = jcp.mb * jcp.itiles * jcp.jtiles;

    status_t res = init_conf_kernel(jcp, jcp.ic, jcp.ntiles, jcp.oc);
    jcp.oc_simd_block = jcp.dimK_reg_block;
    jcp.oc_block = jcp.dimK_block;
    jcp.nb_oc = jcp.dimK_nb_block;
    jcp.ic_simd_block = jcp.dimM_simd_block;
    jcp.ic_block = jcp.dimM_block;
    jcp.nb_ic = jcp.dimM_nb_block;
    jcp.tile_block_ur = jcp.dimN_reg_block;
    jcp.nb_tile_block_ur = jcp.dimN_block;
    jcp.tile_block = jcp.dimN_nb_block;
    jcp.tile_4fma_padding = 0; // only relevant for backward weights

    return res;
}

void jit_avx512_common_conv_winograd_bwd_weights_kernel_f32::transpose_ker_generate()
{
    auto load_B = [=](int reg_idx, int offset) {
        for (int i = 0; i < 4; i++) {
            vmovups(Zmm(reg_idx + i), zword[reg_origB + (offset + i) * jcp.dimN_reg_block * sizeof(float)]);
        }
    };

    int curr = 0;
    for (int j = 0; j < jcp.alpha; j++) {
        for (int i = 0; i < jcp.alpha; i++) {
            int origB_offset = (j * jcp.alpha + i) * jcp.dimK_4fma;
            int transB_offset = (j * jcp.alpha + i) * jcp.dimK_nb_block *
                jcp.dimN_block * jcp.dimK_block * jcp.dimK_reg_block *
                jcp.dimK_4fma * jcp.dimN_reg_block;
            for (int tb = 0; tb < jcp.dimK_4fma; tb+=4) {
                /*double buffering to hide load latencies*/
                int next = (curr + 4) % 8;
                if (i == 0 && tb == 0) {
                    load_B(0, origB_offset);
                }
                if (tb + 4 < (jcp.dimK_4fma -1)) {
                    load_B(next, origB_offset + 4);
                } else if (i < jcp.alpha - 1) {
                    load_B(next, origB_offset + jcp.dimK_4fma);
                }

                vunpcklps(Zmm(8), Zmm(curr), Zmm(curr + 1));
                vunpcklps(Zmm(9), Zmm(curr + 2), Zmm(curr + 3));
                vunpckhps(Zmm(curr), Zmm(curr), Zmm(curr + 1));
                vunpckhps(Zmm(curr + 1), Zmm(curr + 2), Zmm(curr + 3));

                vunpcklpd(Zmm(curr + 2), Zmm(8), Zmm(9));
                vunpckhpd(Zmm(curr + 3), Zmm(8), Zmm(9));

                vunpcklpd(Zmm(8), Zmm(curr), Zmm(curr + 1));
                vunpckhpd(Zmm(9), Zmm(curr), Zmm(curr + 1));

                vmovntps(zword[reg_transB
                        + sizeof(float) * (transB_offset + tb * jcp.dimN_reg_block)],
                        Zmm(curr+2));
                vmovntps(zword[reg_transB
                        + sizeof(float) * (transB_offset + (tb + 1) * jcp.dimN_reg_block)],
                        Zmm(curr+3));
                vmovntps(zword[reg_transB
                        + sizeof(float) * (transB_offset + (tb + 2) * jcp.dimN_reg_block)],
                        Zmm(8));
                vmovntps(zword[reg_transB
                        + sizeof(float) * (transB_offset + (tb + 3) * jcp.dimN_reg_block)],
                        Zmm(9));
                curr = next;

            }
        }
    }
    ret();
}
void jit_avx512_common_conv_winograd_bwd_weights_kernel_f32::gemm_loop_generate(
        bool is_first_tile)
{
    // for (int ofm2 = 0; ofm2 < jcp.oc_block; ofm2++)
    //     for (int ifm2 = 0; ifm2 < jcp.ic_block; ifm2++)
    //             for (int nb_tile_block_ur = 0; nb_tile_block_ur <
    //             jcp.nb_tile_block_ur; nb_tile_block_ur++)
    //                 for (int tile_block_ur = 0; tile_block_ur <
    //                 jcp.tile_block_ur; tile_block_ur++)
    //                     for (int ifm3 = 0; ifm3 < jcp.ic_reg_block; ++ifm3)
    //                         U[ofm2][ifm2][ofm3][ifm3][0:oc_simd_block] +=
    //                             M[ofm2][ofm3][nb_tile_block_ur][tile_block_ur][0:oc_simd_block]
    //                              *
    //                              broadcast(V[ifm2][nb_tile_block_ur][ifm3][tile_block_ur])
    auto inner_loops = [=]() {
        int inc_fma = jcp.ver == ver_4fma ? 4 : 1;
        const int fma_ipc = jcp.ver == ver_4fma ? 1 : 2;
        prefetcher_t<float> L1_pf(this, reg_srcB, L1,
                jcp.dimK_reg_block * jcp.dimN_reg_block * jcp.dimK_4fma,
                jcp.dimK_reg_block * jcp.dimN_reg_block * jcp.dimK_4fma
                        / inc_fma,
                fma_ipc);
        prefetcher_t<float> L2_pf(this, reg_srcB, L2,
                jcp.dimK_reg_block * jcp.dimN_reg_block * jcp.dimK_4fma,
                jcp.dimK_reg_block * jcp.dimN_reg_block * jcp.dimK_4fma
                        / inc_fma,
                fma_ipc);

        auto load_A = [=](int reg_idx, int offset) {
            for (int i = 0; i < inc_fma; i++) {
                vmovups(Zmm(reg_idx + i),
                        zword[reg_srcA +
                        sizeof(float) * jcp.dimM_simd_block * (offset + i)]);
            }
        };

        Label dimM_block_loop, dimK_block_loop, dimN_block_loop;
        if (jcp.dimM_block > 1) {
            mov(reg_dimM_block_loop_cnt, jcp.dimM_block);
            L(dimM_block_loop);
        }
        { /************* OC_block (M) loop ***********/
            if (jcp.dimN_block > 1) {
                mov(reg_dimN_block_loop_cnt, jcp.dimN_block);
                L(dimN_block_loop);
            }
            { /*************** IC_block (N) loop *********/
                for (int dimN_reg_block = 0;
                        dimN_reg_block < jcp.dimN_reg_block; ++dimN_reg_block) {
                    Zmm zmm(jcp.zmm_start + dimN_reg_block);
                    if (is_first_tile)
                        vpxord(zmm, zmm, zmm);
                    else
                        vmovups(zmm, zword[reg_dstC +
                                dimN_reg_block * jcp.dimM_simd_block *
                                sizeof(float)]);
                }

                if (jcp.dimK_block > 1) {
                    mov(reg_dimK_block_loop_cnt, jcp.dimK_block);
                    L(dimK_block_loop);
                }
                { /************* nb_tile_ur(K) loop ********/
                    int next = 0;
                    if (jcp.double_buffering) {
                        load_A(next, 0);
                    }
                    for (int dimK_reg_block = 0;
                            dimK_reg_block < jcp.dimK_reg_block;
                            dimK_reg_block++) {
                        int srcB_offset = dimK_reg_block * jcp.dimK_4fma
                                * jcp.dimN_reg_block;
                        for (int dimK_4fma = 0; dimK_4fma < jcp.dimK_4fma;
                                dimK_4fma += inc_fma) {
                            int current = next;
                            if (jcp.double_buffering) {
                                next = (dimK_reg_block * jcp.dimK_4fma
                                               + dimK_4fma + inc_fma)
                                        % (2 * inc_fma);
                                load_A(next, dimK_reg_block * jcp.dimK_4fma
                                                + dimK_4fma + inc_fma);
                            } else {
                                next = 0;
                                load_A(next, dimK_reg_block * jcp.dimK_4fma
                                                + dimK_4fma);
                            }
                            for (int dimN_reg_block = 0;
                                    dimN_reg_block < jcp.dimN_reg_block;
                                    ++dimN_reg_block) {
                                L1_pf.prefetch(srcB_offset / inc_fma
                                        + dimK_4fma / inc_fma
                                                * jcp.dimN_reg_block
                                        + dimN_reg_block);
                                L2_pf.prefetch(srcB_offset / inc_fma
                                        + dimK_4fma / inc_fma
                                                * jcp.dimN_reg_block
                                        + dimN_reg_block);
                                if (jcp.ver == ver_4fma) {
                                    int srcB_trans_offset = (dimK_4fma / 4) * 64
                                            + dimK_4fma % 4;
                                    v4fmaddps(
                                            Zmm(jcp.zmm_start + dimN_reg_block),
                                            Zmm(current),
                                            EVEX_compress_addr(reg_srcB,
                                                    sizeof(float) * (
                                                        srcB_offset +
                                                        srcB_trans_offset +
                                                        (dimN_reg_block % 4) * 16 +
                                                        (dimN_reg_block / 4) * 4)));
                                } else {
                                    vfmadd231ps(
                                            Zmm(jcp.zmm_start + dimN_reg_block),
                                            Zmm(current),
                                            EVEX_compress_addr(reg_srcB,
                                                sizeof(float) * (srcB_offset + dimN_reg_block),
                                                    true));
                                }
                            }
                        }
                    }
                }

                add(reg_srcA, jcp.dimK_reg_block * jcp.dimK_4fma
                                * jcp.dimM_simd_block * sizeof(float));
                add(reg_srcB, jcp.dimK_reg_block * jcp.dimN_reg_block
                                * jcp.dimK_4fma * sizeof(float));
                if (jcp.dimK_block > 1) {
                    sub(reg_dimK_block_loop_cnt, 1);
                    jnz(dimK_block_loop);
                }

                /******** Write C back to memory *******/
                for (int dimN_reg_block = 0;
                        dimN_reg_block < jcp.dimN_reg_block; ++dimN_reg_block) {
                    Zmm zmm(jcp.zmm_start + dimN_reg_block);
                    vmovups(zword[reg_dstC +
                            dimN_reg_block * jcp.dimM_simd_block * sizeof(float)],
                            zmm);
                }

                sub(reg_srcA, jcp.dimK_block * jcp.dimK_reg_block *
                        jcp.dimK_4fma * jcp.dimM_simd_block * sizeof(float));
                add(reg_dstC, jcp.dimN_reg_block * jcp.dimM_simd_block
                        * sizeof(float));
                if (jcp.dimN_block > 1) {
                    sub(reg_dimN_block_loop_cnt, 1);
                    jnz(dimN_block_loop);
                }
            }

            if (jcp.dimM_block > 1) {
                sub(reg_srcB, jcp.dimN_block * jcp.dimK_block
                                * jcp.dimK_reg_block * jcp.dimN_reg_block
                                * jcp.dimK_4fma * sizeof(float));
                add(reg_srcA, jcp.dimK_block * jcp.dimK_reg_block
                                * jcp.dimK_4fma * jcp.dimM_simd_block * sizeof(float));
                sub(reg_dimM_block_loop_cnt, 1);
                jnz(dimM_block_loop);
            }
        }
    };

    /* Preamble */
    // register used to handle long fma encoding
    push(reg_EVEX_max_8b_offt);
    push(reg_dimK_block_loop_cnt);
    mov(reg_EVEX_max_8b_offt, 2 * EVEX_max_8b_offt);
    mov(reg_srcA, reg_srcA_const);
    inner_loops();

    /* Postamble */
    pop(reg_dimK_block_loop_cnt);
    pop(reg_EVEX_max_8b_offt);
    ret();
}

namespace {
bool check_cond1_wu(int dimM_block, int dimM_simdw, int dimK_block,
        int dimK_reg_block, int dimK_4fma, int dimN_reg_block, float C)
{
    float lhs = 1.0f * dimM_block * dimN_reg_block * dimM_simdw;
    lhs += dimM_block * dimK_block * dimK_reg_block * dimK_4fma * dimM_simdw;
    lhs += dimK_block * dimN_reg_block * dimK_reg_block * dimK_4fma;
    lhs *= sizeof(float);
    float rhs = C * L1_cache_size;
    return (lhs <= rhs);
}

bool check_cond1bis_wu(int dimM_block, int dimM_simdw, int dimK_block,
        int dimK_reg_block, int dimK_4fma, int dimN_reg_block, float C)
{
    float lhs = 1.0f * dimM_block * dimK_block * dimK_reg_block * dimK_4fma
            * dimM_simdw;
    lhs += dimK_block * dimN_reg_block * dimK_reg_block * dimK_4fma;
    lhs *= sizeof(float);
    float rhs = C * L1_cache_size;
    return (lhs <= rhs);
}

bool check_cond2bis_wu(int dimM_block, int dimM_simdw, int dimK_block,
        int dimK_reg_block, int dimK_4fma, int dimN_block, int dimN_reg_block,
        float C)
{
    float lhs = 1.0f * dimM_block * dimM_simdw * dimK_block * dimK_reg_block
            * dimK_4fma;
    lhs += dimK_block * dimK_reg_block * dimK_4fma * dimN_block
            * dimN_reg_block;
    lhs *= sizeof(float);
    float rhs = C * L2_cache_size;
    return (lhs <= rhs);
}

bool check_cond2_wu(int dimM_block, int dimM_simdw, int dimK_block,
        int dimK_reg_block, int dimK_4fma, int dimN_block, int dimN_reg_block,
        float C)
{
    float lhs = 1.0f * dimM_block * dimM_simdw * dimN_block * dimN_reg_block;
    lhs += dimM_block * dimM_simdw * dimK_block * dimK_reg_block * dimK_4fma;
    lhs += dimK_block * dimK_reg_block * dimK_4fma * dimN_block
            * dimN_reg_block;
    lhs *= sizeof(float);
    float rhs = C * L2_cache_size;
    return (lhs <= rhs);
}
} // namespace

bool set_wsched_WEI_S_D_G_W(jit_conv_winograd_conf_t &jcp)
{
    /*************** Choose dimN_reg_block (ic_simd_block)
     * *******************************/
    jcp.dimN = jcp.ic;
    /*Hardcoded to 16 because N = ic for bwd weights and
     innermost dimension for ic is assumed 16 in src transforms. This
     choice covers load latencies while maintaining simplicity of kernel
     for POR topologies. FIXME in future??: Will not work for future topologies
     when ic%16 != 0*/
    jcp.dimN_reg_block = jcp.ic_simd_block;

    /****************************** Choose dimK_block
     * **************************/
    // No freedom for choosing dimM_simd_block because ic_simd_block
    // is determined by input data format
    jcp.dimM_simd_block = jcp.oc_simd_block;

    auto test_cond1bis_dimK_block = [](
            jit_conv_winograd_conf_t &jcp, int dimK_block, int current_best) {
        return check_cond1bis_wu(1, jcp.dimM_simd_block, dimK_block, 1,
                       jcp.dimK_4fma, jcp.dimN_reg_block, 0.4f)
                && (dimK_block > current_best);
    };

    auto test_cond1_dimK_block = [](
            jit_conv_winograd_conf_t &jcp, int dimK_block, int current_best) {
        return check_cond1_wu(1, jcp.dimM_simd_block, dimK_block, 1,
                       jcp.dimK_4fma, jcp.dimN_reg_block, 0.4f)
                && (dimK_block > current_best);
    };

    auto test_cond2bis_dimK_block = [](
            jit_conv_winograd_conf_t &jcp, int dimK_block, int current_best) {
        return check_cond2bis_wu(1, jcp.dimM_simd_block, dimK_block, 1,
                       jcp.dimK_4fma, 1, jcp.dimN_reg_block, 0.5f)
                && (dimK_block > current_best);
    };

    auto test_cond2_dimK_block = [](
            jit_conv_winograd_conf_t &jcp, int dimK_block, int current_best) {
        return check_cond2_wu(1, jcp.dimM_simd_block, dimK_block, 1,
                       jcp.dimK_4fma, 1, jcp.dimN_reg_block, 0.1f)
                && (dimK_block > current_best);
    };

    jcp.dimK_block = get_divisor_satisfying_cond(
            jcp, jcp.dimK / jcp.dimK_4fma, 1, test_cond2bis_dimK_block);
    if (jcp.dimK_block < jcp.dimK / jcp.dimK_4fma)
        jcp.dimK_block = get_divisor_satisfying_cond(
                jcp, jcp.dimK / jcp.dimK_4fma, 1, test_cond2_dimK_block);

    jcp.dimK_reg_block = get_divisor_satisfying_cond(
            jcp, jcp.dimK_block, 1, test_cond1bis_dimK_block);
    if (jcp.dimK_reg_block < jcp.dimK_block) {
        jcp.dimK_reg_block = get_divisor_satisfying_cond(
                jcp, jcp.dimK_block, 1, test_cond1_dimK_block);
    }
    jcp.dimK_block /= jcp.dimK_reg_block;
    jcp.dimK_nb_block
            = jcp.dimK / jcp.dimK_4fma / jcp.dimK_reg_block / jcp.dimK_block;
    jcp.tile_block_ur = jcp.dimK_reg_block;
    jcp.nb_tile_block_ur = jcp.dimK_block;
    jcp.tile_block = jcp.dimK_nb_block;

    /***************************** Chose dimN block
     * ****************************/
    auto test_cond2_dimN_block = [](
            jit_conv_winograd_conf_t &jcp, int dimN_block, int current_best) {
        return check_cond2_wu(1, jcp.dimM_simd_block, jcp.dimK_block,
                       jcp.dimK_reg_block, jcp.dimK_4fma, dimN_block,
                       jcp.dimN_reg_block, 0.5f)
                && (dimN_block > current_best);
    };

    jcp.dimN_block = get_divisor_satisfying_cond(
            jcp, jcp.dimN / jcp.dimN_reg_block, 1, test_cond2_dimN_block);
    jcp.ic_block = jcp.dimN_block;
    jcp.dimN_nb_block = jcp.dimN / jcp.dimN_reg_block / jcp.dimN_block;
    jcp.nb_ic = jcp.dimN_nb_block;

    /********************************* Choose dimM block
     * ************************/
    jcp.dimM = jcp.oc;

    auto test_cond1_dimM_block = [](
            jit_conv_winograd_conf_t &jcp, int dimM_block, int current_best) {
        return check_cond1_wu(dimM_block, jcp.dimM_simd_block, 1,
                       jcp.dimK_reg_block, jcp.dimK_4fma, jcp.dimN_reg_block,
                       1.0f)
                && (dimM_block > current_best)
                && (jcp.dimM / jcp.dimM_simd_block / dimM_block) >= 2;
    };

    jcp.dimM_block = get_divisor_satisfying_cond(
            jcp, jcp.dimM / jcp.dimM_simd_block, 1, test_cond1_dimM_block);
    jcp.dimM_nb_block = (jcp.dimM / jcp.dimM_simd_block) / jcp.dimM_block;

    jcp.sched_policy = WSCHED_WEI_S_D_G_W;
    return true;
}

namespace {
bool is_in_L1_range(int v, float C1, float C2)
{
    return ((v > C1 * L1_cache_size) && (v < C2 * L1_cache_size));
}

bool is_in_L2_range(int v, float C1, float C2)
{
    return ((v > C1 * L2_cache_size) && (v < C2 * L2_cache_size));
}

void set_jcp_WEI_params(jit_conv_winograd_conf_t &jcp, int tile_block_ur,
        int tile_block, int nb_ic, int nb_oc)
{
    jcp.tile_block_ur = tile_block_ur;
    jcp.tile_block = tile_block;
    jcp.nb_ic = nb_ic;
    jcp.nb_oc = nb_oc;

    jcp.nb_tile_block_ur = jcp.ntiles / jcp.tile_block / jcp.tile_block_ur;
    jcp.ic_block = jcp.ic / jcp.ic_simd_block / jcp.nb_ic;
    jcp.oc_block = jcp.oc / jcp.oc_simd_block / jcp.nb_oc;

    jcp.dimK_reg_block = jcp.tile_block_ur;
    jcp.dimK_block = jcp.nb_tile_block_ur;
    jcp.dimK_nb_block = jcp.tile_block;
    jcp.dimN_reg_block = jcp.ic_simd_block;
    jcp.dimN_block = jcp.ic_block;
    jcp.dimN_nb_block = jcp.nb_ic;
    jcp.dimM_simd_block = jcp.oc_simd_block;
    jcp.dimM_block = jcp.oc_block;
    jcp.dimM_nb_block = jcp.nb_oc;
}
} // namespace

bool set_wsched_WEI_SDGt_W(jit_conv_winograd_conf_t &jcp)
{
    jcp.ic_simd_block = jcp.oc_simd_block = 16;
    int nb_ic_simd_block = jcp.ic / jcp.ic_simd_block;
    int nb_oc_simd_block = jcp.oc / jcp.oc_simd_block;

    int min_tile_block_ur = 8;
    int max_tile_block_ur = 64;
    int max_tile_block = jcp.ntiles / min_tile_block_ur;

    // Consider L2 + L3 together on SKX
    const float C1_min = .1, C1_0 = .4, C1_max = .5;
    const float C2_0 = .4, C2_max = .5;
    const float TC2_0 = .7, TC2_max = 1.2;
    const int T_min = 2, T0 = 20;
    float C1, C2, TC2;
    int T, tile_block, tile_block_ur, nb_oc, nb_ic;

    auto blocking_ok = [&]() -> bool {
        // V:tile_block + M:tile_block + U
        int thread_size = jcp.alpha * jcp.alpha * jcp.oc
                        * (jcp.ntiles / tile_block) * sizeof(float)
                + jcp.alpha * jcp.alpha * jcp.ic * (jcp.ntiles / tile_block)
                        * sizeof(float)
                + jcp.alpha * jcp.alpha * jcp.ic * jcp.oc * sizeof(float);
        // V:tile_block + M:tile_block
        int L2_reuse = jcp.alpha * jcp.alpha * jcp.oc
                        * (jcp.ntiles / tile_block) * sizeof(float)
                + jcp.alpha * jcp.alpha * jcp.ic * (jcp.ntiles / tile_block)
                        * sizeof(float);
        // V:nb_ic + M:nb_tile_block_ur
        // Use M:nb_oc + V:nb_ic as an superset estimation
        int L1_reuse
                = (jcp.ic / nb_ic) * (jcp.ntiles / tile_block) * sizeof(float)
                + (jcp.oc / nb_oc) * (jcp.ntiles / tile_block) * sizeof(float);

        return jcp.ntiles % tile_block == 0
                && (jcp.ntiles / tile_block) % tile_block_ur == 0
                && is_in_L2_range(thread_size, TC2, TC2_max)
                && is_in_L2_range(L2_reuse, C2, C2_max)
                && tile_block > T * omp_get_max_threads()
                && nb_oc_simd_block % nb_oc == 0
                && nb_ic_simd_block % nb_ic == 0
                && is_in_L1_range(L1_reuse, C1, C1_max);
    };

    for (C1 = C1_0, C2 = C2_0, TC2 = TC2_0; C1 > C1_min;
            C1 -= .02, C2 -= .02, TC2 -= .04) {
        for (T = T0; T >= T_min; --T) {
            for (tile_block = 1; tile_block <= max_tile_block; ++tile_block) {
                for (tile_block_ur = max_tile_block_ur;
                        tile_block_ur >= min_tile_block_ur; --tile_block_ur) {
                    for (nb_oc = 1; nb_oc <= nb_oc_simd_block; ++nb_oc) {
                        for (nb_ic = nb_ic_simd_block; nb_ic >= 1; --nb_ic) {
                            if (blocking_ok()) {
                                set_jcp_WEI_params(jcp, tile_block_ur,
                                        tile_block, nb_ic, nb_oc);
                                jcp.sched_policy = WSCHED_WEI_SDGt_W;
                                return true;
                            }
                        }
                    }
                }
            }
        }
    }

    return false;
}

bool set_wsched_WEI_SDGtWo(jit_conv_winograd_conf_t &jcp)
{
    jcp.ic_simd_block = jcp.oc_simd_block = 16;
    int nb_ic_simd_block = jcp.ic / jcp.ic_simd_block;
    int nb_oc_simd_block = jcp.oc / jcp.oc_simd_block;

    int min_tile_block_ur = 12;
    int max_tile_block_ur = 64;
    int max_tile_block = jcp.ntiles / min_tile_block_ur;

    const float C1_min = .1, C1_0 = .4, C1_max = .5;
    const float C2_0 = .4, C2_max = .6;
    const float TC2_0 = .7, TC2_max = 1.6;

    const int max_nb_oc = 2; // Limit the # of sequential execution
    const int T0 = 12, T_min = 8;
    float C1, C2, TC2;
    int T, tile_block, tile_block_ur, nb_oc, nb_ic;

    auto blocking_ok = [&]() -> bool {
        // M:tile_block:nb_oc + V:tile_block + U:nb_oc
        int thread_size = jcp.alpha * jcp.alpha * (jcp.oc / nb_oc)
                        * (jcp.ntiles / tile_block) * sizeof(float)
                + jcp.alpha * jcp.alpha * jcp.ic * (jcp.ntiles / tile_block)
                        * sizeof(float)
                + jcp.alpha * jcp.alpha * jcp.ic * (jcp.oc / nb_oc)
                        * sizeof(float);
        // M:tile_block:nb_oc + V:tile_block
        int L2_reuse = jcp.alpha * jcp.alpha * (jcp.oc / nb_oc)
                        * (jcp.ntiles / tile_block) * sizeof(float)
                + jcp.alpha * jcp.alpha * jcp.ic * (jcp.ntiles / tile_block)
                        * sizeof(float);
        // V:nb_ic + M:nb_tile_block_ur
        // Use M:nb_oc + V:nb_ic as an superset estimation
        int L1_reuse
                = (jcp.ic / nb_ic) * (jcp.ntiles / tile_block) * sizeof(float)
                + (jcp.oc / nb_oc) * (jcp.ntiles / tile_block) * sizeof(float);

        return jcp.ntiles % tile_block == 0
                && (jcp.ntiles / tile_block) % tile_block_ur == 0
                && is_in_L2_range(thread_size, TC2, TC2_max)
                && is_in_L2_range(L2_reuse, C2, C2_max)
                && tile_block > T * omp_get_max_threads()
                && nb_oc_simd_block % nb_oc == 0
                && nb_ic_simd_block % nb_ic == 0
                && is_in_L1_range(L1_reuse, C1, C1_max);
    };

    for (T = T0; T >= T_min; --T) {
        for (C1 = C1_0, C2 = C2_0, TC2 = TC2_0; C1 > C1_min;
                C1 -= .02, C2 -= .02, TC2 -= .04) {
            for (nb_oc = 1; nb_oc <= max_nb_oc; ++nb_oc) {
                for (tile_block = max_tile_block; tile_block >= 1;
                        --tile_block) {
                    for (tile_block_ur = min_tile_block_ur;
                            tile_block_ur <= max_tile_block_ur;
                            ++tile_block_ur) {
                        for (nb_ic = 1; nb_ic <= nb_ic_simd_block; ++nb_ic) {
                            if (blocking_ok()) {
                                set_jcp_WEI_params(jcp, tile_block_ur,
                                        tile_block, nb_ic, nb_oc);
                                jcp.sched_policy = WSCHED_WEI_SDGtWo;
                                return true;
                            }
                        }
                    }
                }
            }
        }
    }

    return false;
}

bool set_wsched_WEI_S_D_Giot_W(jit_conv_winograd_conf_t &jcp)
{
    jcp.ic_simd_block = jcp.oc_simd_block = 16;
    int nb_ic_simd_block = jcp.ic / jcp.ic_simd_block;

    int min_tile_block_ur = 8;
    int max_tile_block_ur = 64;
    const float C1_min = .2, C1_0 = .4, C1_max = .9;
    const float C2_min = .1, C2_0 = .4, C2_max = .5;
    const int T0 = 16, T_min = 12;
    float C1, C2;
    int T, tile_block, tile_block_ur, nb_ic;
    int nb_oc = 1; // Keep nb_oc small to increase
                   // oc_block, for better reuse of V in
                   // L2

    auto blocking_ok = [&]() -> bool {
        // V[:ic_block][][][]
        int L2_reuse
                = (jcp.ic / nb_ic) * (jcp.ntiles / tile_block) * sizeof(float);
        // M[:nb_tile_block_ur][][] + V[:nb_tile_block_ur][][]
        int L1_reuse
                = (jcp.ntiles / tile_block) * jcp.oc_simd_block * sizeof(float);

        int work_amount = tile_block * nb_ic * nb_oc * jcp.alpha * jcp.alpha;

        return (jcp.ntiles / tile_block_ur) % tile_block == 0
                && jcp.ntiles % tile_block_ur == 0
                && nb_ic_simd_block % nb_ic == 0
                && is_in_L2_range(L2_reuse, C2, C2_max)
                && is_in_L1_range(L1_reuse, C1, C1_max)
                && work_amount > T * omp_get_max_threads();
    };

    for (T = T0; T >= T_min; --T) {
        for (C1 = C1_0; C1 > C1_min; C1 -= .02) {
            for (C2 = C2_0; C2 > C2_min; C2 -= .02) {
                for (nb_ic = 1; nb_ic <= nb_ic_simd_block; ++nb_ic) {
                    for (tile_block_ur = min_tile_block_ur;
                            tile_block_ur <= max_tile_block_ur;
                            ++tile_block_ur) {
                        for (tile_block = 1;
                                tile_block <= jcp.ntiles / min_tile_block_ur;
                                ++tile_block) {
                            if (blocking_ok()) {
                                set_jcp_WEI_params(jcp, tile_block_ur,
                                        tile_block, nb_ic, nb_oc);
                                jcp.sched_policy = WSCHED_WEI_S_D_Giot_W;
                                return true;
                            }
                        }
                    }
                }
            }
        }
    }
    return false;
}

status_t jit_avx512_common_conv_winograd_bwd_weights_kernel_f32::init_conf(
        jit_conv_winograd_conf_t &jcp, const convolution_desc_t &cd,
        const memory_desc_wrapper &src_d, const memory_desc_wrapper &diff_dst_d,
        const memory_desc_wrapper &diff_weights_d)
{
    if (!mayiuse(avx512_common))
        return status::unimplemented;

    const bool with_groups = diff_weights_d.ndims() == src_d.ndims() + 1;
    const int simd_w = 16;

    jcp.ngroups = with_groups ? diff_weights_d.dims()[0] : 1;
    jcp.mb = src_d.dims()[0];
    jcp.oc = diff_dst_d.dims()[1] / jcp.ngroups;
    jcp.ic = src_d.dims()[1] / jcp.ngroups;
    jcp.ih = src_d.dims()[2];
    jcp.iw = src_d.dims()[3];
    jcp.oh = diff_dst_d.dims()[2];
    jcp.ow = diff_dst_d.dims()[3];
    jcp.kh = diff_weights_d.dims()[with_groups + 2];
    jcp.kw = diff_weights_d.dims()[with_groups + 3];
    jcp.t_pad = cd.padding[0][0];
    jcp.l_pad = cd.padding[0][1];
    jcp.stride_h = cd.strides[0];
    jcp.stride_w = cd.strides[1];
    jcp.r_pad = nstl::max(
            0, (jcp.ow - 1) * jcp.stride_w + jcp.kw - jcp.iw - jcp.l_pad);
    jcp.b_pad = nstl::max(
            0, (jcp.oh - 1) * jcp.stride_h + jcp.kh - jcp.ih - jcp.t_pad);
    jcp.ihp = jcp.ih + jcp.t_pad + jcp.b_pad;
    jcp.iwp = jcp.iw + jcp.l_pad + jcp.r_pad;
    jcp.ohp = jcp.oh;
    jcp.owp = jcp.ow;
    jcp.with_bias = (cd.diff_bias_desc.format != memory_format::undef);
    jcp.dilate_h = cd.dilates[0];
    jcp.dilate_w = cd.dilates[1];

    if (!mayiuse(avx512_common))
        return status::unimplemented;
    else if (mayiuse(avx512_core))
        jcp.ver = ver_avx512_core;
    else if (mayiuse(avx512_mic_4ops))
        jcp.ver = ver_4fma;
    else
        jcp.ver = ver_fma;

    // Winograd specific initialization
    const int tile_size = jcp.alpha - 2;
    jcp.itiles = (jcp.ow + tile_size - 1) / tile_size;
    jcp.jtiles = (jcp.oh + tile_size - 1) / tile_size;
    jcp.ntiles = jcp.mb * jcp.itiles * jcp.jtiles;

    // Winograd kernel works only for 3x3 convolution with stride 1
    if (jcp.ngroups != 1)
        return status::unimplemented;
    if ((jcp.kh != 3) || (jcp.kw != 3))
        return status::unimplemented;
    if ((jcp.dilate_h != 0) || (jcp.dilate_w != 0))
        return status::unimplemented;
    if ((jcp.stride_h != 1) || (jcp.stride_w != 1))
        return status::unimplemented;
    if ((jcp.ic % simd_w) != 0 || (jcp.oc % simd_w) != 0)
        return status::unimplemented;
    if (src_d.format() != nChw16c)
        return status::unimplemented;
    if (diff_weights_d.format() != (with_groups ? gOIhw16i16o : OIhw16i16o))
        return status::unimplemented;
    if (diff_dst_d.format() != nChw16c)
        return status::unimplemented;

    /*************************** New Kernel Parameters
     * *****************************/
    jcp.ic_simd_block = simd_w;
    jcp.oc_simd_block = simd_w;
    jcp.dimK_4fma = 1;
    jcp.tile_4fma_padding = 0;

#define MAX_4FMA_UR 8
    if (jcp.ver == ver_4fma) {
        auto test_cond_4fma = [](jit_conv_winograd_conf_t &jcp, int dimK_4fma,
                                      int current_best) {
            return (dimK_4fma % 4 == 0) && (dimK_4fma <= MAX_4FMA_UR)
                    && (dimK_4fma > current_best);
        };
        jcp.dimK_4fma = get_divisor_satisfying_cond(
                jcp, jcp.itiles * jcp.jtiles, 4, test_cond_4fma);
        if (jcp.dimK_4fma == 1)
            jcp.dimK_4fma = 4;
        if ((jcp.itiles * jcp.jtiles) % jcp.dimK_4fma != 0)
            jcp.tile_4fma_padding = jcp.dimK_4fma
                    - ((jcp.itiles * jcp.jtiles) % jcp.dimK_4fma);
    }

    jcp.tile_4fma = jcp.dimK_4fma;
    /*NOTE: When (itiles * jtiles) % dimK_4fma != 0, transpose in diff_src
     * transform
     * will not work correctly, this is solved by applying padding.*/
    jcp.dimK = jcp.mb * (jcp.itiles * jcp.jtiles + jcp.tile_4fma_padding);
    jcp.dimN = jcp.ic;
    jcp.dimM = jcp.oc;

    jcp.double_buffering = true;
    if (jcp.double_buffering)
        jcp.zmm_start = jcp.ver == ver_4fma ? 8 : 2;
    else
        jcp.zmm_start = jcp.ver == ver_4fma ? 4 : 1;
    jcp.nb_reg = 32 - jcp.zmm_start;

    status_t res;
    jcp.sched_policy = WSCHED_INVALID;
    if ((jcp.ver == ver_avx512_core &&
            (set_wsched_WEI_SDGt_W(jcp)
            || set_wsched_WEI_SDGtWo(jcp)
            || set_wsched_WEI_S_D_Giot_W(jcp)))
        || set_wsched_WEI_S_D_G_W(jcp))
        res = status::success;
    else
        return status::unimplemented;

    jcp.tile_block_ur = jcp.dimK_reg_block;
    jcp.nb_tile_block_ur = jcp.dimK_block;
    jcp.tile_block = jcp.dimK_nb_block;

    jcp.ic_block = jcp.dimN_block;
    jcp.nb_ic = jcp.dimN_nb_block;

    jcp.oc_block = jcp.dimM_block;
    jcp.nb_oc = jcp.dimM_nb_block;

    return res;

}
}
}
}

// vim: et ts=4 sw=4 cindent cino^=l0,\\:0,N-s
",16194,True,3423.2880613638804,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
| *basicPropertyBinding* (advanced) | *Deprecated* Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
| *channelGroup* (advanced) | To use a explicit ChannelGroup. |  | ChannelGroup
| *nativeTransport* (advanced) | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: \\http://netty.io/wiki/native-transports.html | false | boolean
| *options* (advanced) | Allows to configure additional netty options using option. as prefix. For example option.child.keepAlive=false to set the netty option child.keepAlive=false. See the Netty documentation for possible options that can be used. |  | Map
| *receiveBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. | 65536 | int
| *receiveBufferSizePredictor* (advanced) | Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |  | int
| *sendBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. | 65536 | int
| *transferExchange* (advanced) | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *udpByteArrayCodec* (advanced) | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | boolean
| *workerCount* (advanced) | When netty works on nio mode, it uses default workerCount parameter from Netty (which is cpu_core_threads x 2). User can use this option to override the default workerCount from Netty. |  | int
| *workerGroup* (advanced) | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. |  | EventLoopGroup
| *allowDefaultCodec* (codec) | The netty component installs a default codec if both, encoder/decoder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | boolean
| *autoAppendDelimiter* (codec) | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | boolean
| *decoderMaxLineLength* (codec) | The max line length to use for the textline codec. | 1024 | int
| *decoders* (codec) | A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *delimiter* (codec) | The delimiter to use for the textline codec. Possible values are LINE and NULL. There are 2 enums and the value can be one of: LINE, NULL | LINE | TextLineDelimiter
| *encoders* (codec) | A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *encoding* (codec) | The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |  | String
| *textline* (codec) | Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP - however only Strings are allowed to be serialized by default. | false | boolean
| *enabledProtocols* (security) | Which protocols to enable when using SSL | TLSv1,TLSv1.1,TLSv1.2 | String
| *keyStoreFile* (security) | Client side certificate keystore to be used for encryption |  | File
| *keyStoreFormat* (security) | Keystore format to be used for payload encryption. Defaults to JKS if not set |  | String
| *keyStoreResource* (security) | Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *needClientAuth* (security) | Configures whether the server needs client authentication when using SSL. | false | boolean
| *passphrase* (security) | Password setting to use in order to encrypt/decrypt payloads sent using SSH |  | String
| *securityProvider* (security) | Security provider to be used for payload encryption. Defaults to SunX509 if not set. |  | String
| *ssl* (security) | Setting to specify whether SSL encryption is applied to this endpoint | false | boolean
| *sslClientCertHeaders* (security) | When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. | false | boolean
| *sslContextParameters* (security) | To configure security using SSLContextParameters |  | SSLContextParameters
| *sslHandler* (security) | Reference to a class that could be used to return an SSL Handler |  | SslHandler
| *trustStoreFile* (security) | Server side certificate keystore to be used for encryption |  | File
| *trustStoreResource* (security) | Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *useGlobalSslContextParameters* (security) | Enable usage of global SSL context parameters. | false | boolean
|===
// component options: END


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

----
netty:protocol:host:port
----

with the following path and query parameters:

=== Path Parameters (3 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *protocol* | *Required* The protocol to use which can be tcp or udp. There are 2 enums and the value can be one of: tcp, udp |  | String
| *host* | *Required* The hostname. For the consumer the hostname is localhost or 0.0.0.0. For the producer the hostname is the remote host to connect to |  | String
| *port* | *Required* The host port number |  | int
|===


=== Query Parameters (71 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *disconnect* (common) | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. | false | boolean
| *keepAlive* (common) | Setting to ensure socket is not closed due to inactivity | true | boolean
| *reuseAddress* (common) | Setting to facilitate socket multiplexing | true | boolean
| *reuseChannel* (common) | This option allows producers and consumers (in client mode) to reuse the same Netty Channel for the lifecycle of processing the Exchange. This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection. When using this, the channel is not returned to the connection pool until the Exchange is done; or disconnected if the disconnect option is set to true. The reused Channel is stored on the Exchange as an exchange property with the key NettyConstants#NETTY_CHANNEL which allows you to obtain the channel during routing and use it as well. | false | boolean
| *sync* (common) | Setting to set endpoint as one-way or request-response | true | boolean
| *tcpNoDelay* (common) | Setting to improve TCP protocol performance | true | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *broadcast* (consumer) | Setting to choose Multicast over UDP | false | boolean
| *clientMode* (consumer) | If the clientMode is true, netty consumer will connect the address as a TCP client. | false | boolean
| *reconnect* (consumer) | Used only in clientMode in consumer, the consumer will attempt to reconnect on disconnection if this is enabled | true | boolean
| *reconnectInterval* (consumer) | Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection | 10000 | int
| *backlog* (consumer) | Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200, 500 or 1000, tells the TCP stack how long the accept queue can be If this option is not configured, then the backlog depends on OS setting. |  | int
| *bossCount* (consumer) | When netty works on nio mode, it uses default bossCount parameter from Netty, which is 1. User can use this option to override the default bossCount from Netty | 1 | int
| *bossGroup* (consumer) | Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint |  | EventLoopGroup
| *disconnectOnNoReply* (consumer) | If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back. | true | boolean
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut |  | ExchangePattern
| *nettyServerBootstrapFactory* (consumer) | To use a custom NettyServerBootstrapFactory |  | NettyServerBootstrapFactory
| *networkInterface* (consumer) | When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group. |  | String
| *noReplyLogLevel* (consumer) | If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverClosedChannelException{zwsp}CaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | DEBUG | LoggingLevel
| *serverExceptionCaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an exception then its logged using this logging level. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverInitializerFactory* (consumer) | To use a custom ServerInitializerFactory |  | ServerInitializerFactory
| *usingExecutorService* (consumer) | Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. | true | boolean
| *connectTimeout* (producer) | Time to wait for a socket connection to be available. Value is in milliseconds. | 10000 | int
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *requestTimeout* (producer) | Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milli seconds, so eg 30000 is 30 seconds. The requestTimeout is using Netty's ReadTimeoutHandler to trigger the timeout. |  | long
| *clientInitializerFactory* (producer) | To use a custom ClientInitializerFactory |  | ClientInitializerFactory
| *correlationManager* (producer) | To use a custom correlation manager to manage how request and reply messages are mapped when using request/reply with the netty producer. This should only be used if you have a way to map requests together with replies such as if there is correlation ids in both the request and reply messages. This can be used if you want to multiplex concurrent messages on the same channel (aka connection) in netty. When doing this you must have a way to correlate the request and reply messages so you can store the right reply on the inflight Camel Exchange before its continued routed. We recommend extending the TimeoutCorrelationManagerSupport when you build custom correlation managers. This provides support for timeout and other complexities you otherwise would need to implement as well. See also the producerPoolEnabled option for more details. |  | NettyCamelStateCorrelationManager
| *lazyChannelCreation* (producer) | Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. | true | boolean
| *producerPoolEnabled* (producer) | Whether producer pool is enabled or not. Important: If you turn this off then a single shared connection is used for the producer, also if you are doing request/reply. That means there is a potential issue with interleaved responses if replies comes back out-of-order. Therefore you need to have a correlation id in both the request and reply messages so you can properly correlate the replies to the Camel callback that is responsible for continue processing the message in Camel. To do this you need to implement NettyCamelStateCorrelationManager as correlation manager and configure it via the correlationManager option. See also the correlationManager option for more details. | true | boolean
| *producerPoolMaxActive* (producer) | Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit. | -1 | int
| *producerPoolMaxIdle* (producer) | Sets the cap on the number of idle instances in the pool. | 100 | int
| *producerPoolMinEvictableIdle* (producer) | Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor. | 300000 | long
| *producerPoolMinIdle* (producer) | Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects. |  | int
| *udpConnectionlessSending* (producer) | This option supports connection less udp sending which is a real fire and forget. A connected udp send receive the PortUnreachableException if no one is listen on the receiving port. | false | boolean
| *useByteBuf* (producer) | If the useByteBuf is true, netty producer will turn the message body into ByteBuf before sending it out. | false | boolean
| *allowSerializedHeaders* (advanced) | Only used for TCP when transferExchange is true. When set to true, serializable objects in headers and properties will be added to the exchange. Otherwise Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *basicPropertyBinding* (advanced) | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
| *channelGroup* (advanced) | To use a explicit ChannelGroup. |  | ChannelGroup
| *nativeTransport* (advanced) | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: \\http://netty.io/wiki/native-transports.html | false | boolean
| *options* (advanced) | Allows to configure additional netty options using option. as prefix. For example option.child.keepAlive=false to set the netty option child.keepAlive=false. See the Netty documentation for possible options that can be used. |  | Map
| *receiveBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. | 65536 | int
| *receiveBufferSizePredictor* (advanced) | Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |  | int
| *sendBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. | 65536 | int
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
| *transferExchange* (advanced) | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *udpByteArrayCodec* (advanced) | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | boolean
| *workerCount* (advanced) | When netty works on nio mode, it uses default workerCount parameter from Netty (which is cpu_core_threads x 2). User can use this option to override the default workerCount from Netty. |  | int
| *workerGroup* (advanced) | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. |  | EventLoopGroup
| *allowDefaultCodec* (codec) | The netty component installs a default codec if both, encoder/decoder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | boolean
| *autoAppendDelimiter* (codec) | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | boolean
| *decoderMaxLineLength* (codec) | The max line length to use for the textline codec. | 1024 | int
| *decoders* (codec) | A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *delimiter* (codec) | The delimiter to use for the textline codec. Possible values are LINE and NULL. There are 2 enums and the value can be one of: LINE, NULL | LINE | TextLineDelimiter
| *encoders* (codec) | A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *encoding* (codec) | The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |  | String
| *textline* (codec) | Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP - however only Strings are allowed to be serialized by default. | false | boolean
| *enabledProtocols* (security) | Which protocols to enable when using SSL | TLSv1,TLSv1.1,TLSv1.2 | String
| *keyStoreFile* (security) | Client side certificate keystore to be used for encryption |  | File
| *keyStoreFormat* (security) | Keystore format to be used for payload encryption. Defaults to JKS if not set |  | String
| *keyStoreResource* (security) | Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *needClientAuth* (security) | Configures whether the server needs client authentication when using SSL. | false | boolean
| *passphrase* (security) | Password setting to use in order to encrypt/decrypt payloads sent using SSH |  | String
| *securityProvider* (security) | Security provider to be used for payload encryption. Defaults to SunX509 if not set. |  | String
| *ssl* (security) | Setting to specify whether SSL encryption is applied to this endpoint | false | boolean
| *sslClientCertHeaders* (security) | When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. | false | boolean
| *sslContextParameters* (security) | To configure security using SSLContextParameters |  | SSLContextParameters
| *sslHandler* (security) | Reference to a class that could be used to return an SSL Handler |  | SslHandler
| *trustStoreFile* (security) | Server side certificate keystore to be used for encryption |  | File
| *trustStoreResource* (security) | Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
|===
// endpoint options: END



== Registry based Options

Codec Handlers and SSL Keystores can be enlisted in the Registry, such as in the Spring XML file.
The values that could be passed in, are the following:

[width=""100%"",cols=""10%,90%"",options=""header"",]
|===
|Name |Description

|`passphrase` |password setting to use in order to encrypt/decrypt payloads sent using
SSH

|`keyStoreFormat` |keystore format to be used for payload encryption. Defaults to ""JKS"" if
not set

|`securityProvider` |Security provider to be used for payload encryption. Defaults to
""SunX509"" if not set.

|`keyStoreFile` |*deprecated:* Client side certificate keystore to be used for encryption

|`trustStoreFile` |*deprecated:* Server side certificate keystore to be used for encryption

|`keyStoreResource` |Client side certificate keystore to be used for
encryption. Is loaded by default from classpath, but you can prefix with
`""classpath:""`, `""file:""`, or `""http:""` to load the resource from
different systems.

|`trustStoreResource` |Server side certificate keystore to be used for
encryption. Is loaded by default from classpath, but you can prefix with
`""classpath:""`, `""file:""`, or `""http:""` to load the resource from
different systems.

|`sslHandler` |Reference to a class that could be used to return an SSL Handler

|`encoder` |A custom `ChannelHandler` class that can be used to perform special
marshalling of outbound payloads. Must override
io.netty.channel.ChannelInboundHandlerAdapter.

|`encoders` |A list of encoders to be used. You can use a String which have values
separated by comma, and have the values be looked up in the
Registry. Just remember to prefix the value with #
so Camel knows it should lookup.

|`decoder` |A custom `ChannelHandler` class that can be used to perform special
marshalling of inbound payloads. Must override
io.netty.channel.ChannelOutboundHandlerAdapter.

|`decoders` |A list of decoders to be used. You can use a String which have values
separated by comma, and have the values be looked up in the
Registry. Just remember to prefix the value with #
so Camel knows it should lookup.
|===

[NOTE]
====
Read below about using non shareable encoders/decoders.
====

=== Using non shareable encoders or decoders

If your encoders or decoders are not shareable (e.g. they don't have the
@Shareable class annotation), then your encoder/decoder must implement
the `org.apache.camel.component.netty.ChannelHandlerFactory` interface,
and return a new instance in the `newChannelHandler` method. This is to
ensure the encoder/decoder can safely be used. If this is not the case,
then the Netty component will log a WARN when an endpoint is created.

The Netty component offers a
`org.apache.camel.component.netty.ChannelHandlerFactories` factory
class, that has a number of commonly used methods.

== Sending Messages to/from a Netty endpoint

=== Netty Producer

In Producer mode, the component provides the ability to send payloads to
a socket endpoint using either TCP or UDP protocols (with optional SSL support).

The producer mode supports both one-way and request-response based operations.

=== Netty Consumer

In Consumer mode, the component provides the ability to:

* listen on a specified socket using either TCP or UDP protocols (with
optional SSL support),
* receive requests on the socket using text/xml, binary and serialized
object based payloads and
* send them along on a route as message exchanges.

The consumer mode supports both one-way and request-response based
operations.

== Examples

=== A UDP Netty endpoint using Request-Reply and serialized object payload

Note that Object serialization is not allowed by default, and so a decoder must be configured.

[source,java]
----
@BindToRegistry(""decoder"")
public ChannelHandler getDecoder() throws Exception {
    return new DefaultChannelHandlerFactory() {
        @Override
        public ChannelHandler newChannelHandler() {
            return new DatagramPacketObjectDecoder(ClassResolvers.weakCachingResolver(null));
        }
    };
}

RouteBuilder builder = new RouteBuilder() {
  public void configure() {
    from(""netty:udp://0.0.0.0:5155?sync=true&decoders=#decoder"")
      .process(new Processor() {
         public void process(Exchange exchange) throws Exception {
           Poetry poetry = (Poetry) exchange.getIn().getBody();
           // Process poetry in some way
           exchange.getOut().setBody(""Message received);
         }
       }
    }
};
----

=== A TCP based Netty consumer endpoint using One-way communication

[source,java]
----
RouteBuilder builder = new RouteBuilder() {
  public void configure() {
       from(""netty:tcp://0.0.0.0:5150"")
           .to(""mock:result"");
  }
};
----

=== An SSL/TCP based Netty consumer endpoint using Request-Reply communication

[[Netty-UsingtheJSSEConfigurationUtility]]
Using the JSSE Configuration Utility

The Netty component supports SSL/TLS configuration
through the xref:manual::camel-configuration-utilities.adoc[Camel JSSE
Configuration Utility].  This utility greatly decreases the amount of
component specific code you need to write and is configurable at the
endpoint and component levels.  The following examples demonstrate how
to use the utility with the Netty component.

[[Netty-Programmaticconfigurationofthecomponent]]
Programmatic configuration of the component

[source,java]
----
KeyStoreParameters ksp = new KeyStoreParameters();
ksp.setResource(""/users/home/server/keystore.jks"");
ksp.setPassword(""keystorePassword"");

KeyManagersParameters kmp = new KeyManagersParameters();
kmp.setKeyStore(ksp);
kmp.setKeyPassword(""keyPassword"");

SSLContextParameters scp = new SSLContextParameters();
scp.setKeyManagers(kmp);

NettyComponent nettyComponent = getContext().getComponent(""netty"", NettyComponent.class);
nettyComponent.setSslContextParameters(scp);
----

[[Netty-SpringDSLbasedconfigurationofendpoint]]
Spring DSL based configuration of endpoint

[source,xml]
----
...
  <camel:sslContextParameters
      id=""sslContextParameters"">
    <camel:keyManagers
        keyPassword=""keyPassword"">
      <camel:keyStore
          resource=""/users/home/server/keystore.jks""
          password=""keystorePassword""/>
    </camel:keyManagers>
  </camel:sslContextParameters>...
...
  <to uri=""netty:tcp://0.0.0.0:5150?sync=true&ssl=true&sslContextParameters=#sslContextParameters""/>
...
----

[[Netty-UsingBasicSSLTLSconfigurationontheJettyComponent]]
Using Basic SSL/TLS configuration on the Jetty Component

[source,java]
----
Registry registry = context.getRegistry();
registry.bind(""password"", ""changeit"");
registry.bind(""ksf"", new File(""src/test/resources/keystore.jks""));
registry.bind(""tsf"", new File(""src/test/resources/keystore.jks""));

context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty:tcp://0.0.0.0:5150?sync=true&ssl=true&passphrase=#password""
         + ""&keyStoreFile=#ksf&trustStoreFile=#tsf"";
      String return_string =
         ""When You Go Home, Tell Them Of Us And Say,""
         + ""For Your Tomorrow, We Gave Our Today."";

      from(netty_ssl_endpoint)
       .process(new Processor() {
          public void process(Exchange exchange) throws Exception {
            exchange.getOut().setBody(return_string);
          }
       }
  }
});
----

[[Netty-GettingaccesstoSSLSessionandtheclientcertificate]]
Getting access to SSLSession and the client certificate

You can get access to the `javax.net.ssl.SSLSession` if you eg need to
get details about the client certificate. When `ssl=true` then the
xref:netty-component.adoc[Netty] component will store the `SSLSession` as a
header on the Camel Message as shown below:

[source,java]
----
SSLSession session = exchange.getIn().getHeader(NettyConstants.NETTY_SSL_SESSION, SSLSession.class);
// get the first certificate which is client certificate
javax.security.cert.X509Certificate cert = session.getPeerCertificateChain()[0];
Principal principal = cert.getSubjectDN();
----

Remember to set `needClientAuth=true` to authenticate the client,
otherwise `SSLSession` cannot access information about the client
certificate, and you may get an exception
`javax.net.ssl.SSLPeerUnverifiedException: peer not authenticated`. You
may also get this exception if the client certificate is expired or not
valid etc.

[TIP]
====
The option `sslClientCertHeaders` can be set to `true` which then
enriches the Camel Message with headers having
details about the client certificate. For example the subject name is
readily available in the header `CamelNettySSLClientCertSubjectName`.
====

=== Using Multiple Codecs

In certain cases it may be necessary to add chains of encoders and
decoders to the netty pipeline. To add multpile codecs to a camel netty
endpoint the 'encoders' and 'decoders' uri parameters should be used.
Like the 'encoder' and 'decoder' parameters they are used to supply
references (lists of ChannelUpstreamHandlers and
ChannelDownstreamHandlers) that should be added to the pipeline. Note
that if encoders is specified then the encoder param will be ignored,
similarly for decoders and the decoder param.

[NOTE]
====
Read further above about using non shareable encoders/decoders.
====

The lists of codecs need to be added to the Camel's registry so they can
be resolved when the endpoint is created.

[source,java]
----
ChannelHandlerFactory lengthDecoder = ChannelHandlerFactories.newLengthFieldBasedFrameDecoder(1048576, 0, 4, 0, 4);

StringDecoder stringDecoder = new StringDecoder();
registry.bind(""length-decoder"", lengthDecoder);
registry.bind(""string-decoder"", stringDecoder);

LengthFieldPrepender lengthEncoder = new LengthFieldPrepender(4);
StringEncoder stringEncoder = new StringEncoder();
registry.bind(""length-encoder"", lengthEncoder);
registry.bind(""string-encoder"", stringEncoder);

List<ChannelHandler> decoders = new ArrayList<ChannelHandler>();
decoders.add(lengthDecoder);
decoders.add(stringDecoder);

List<ChannelHandler> encoders = new ArrayList<ChannelHandler>();
encoders.add(lengthEncoder);
encoders.add(stringEncoder);

registry.bind(""encoders"", encoders);
registry.bind(""decoders"", decoders);
----

Spring's native collections support can be used to specify the codec
lists in an application context

[source,xml]
----
<util:list id=""decoders"" list-class=""java.util.LinkedList"">
        <bean class=""org.apache.camel.component.netty.ChannelHandlerFactories"" factory-method=""newLengthFieldBasedFrameDecoder"">
            <constructor-arg value=""1048576""/>
            <constructor-arg value=""0""/>
            <constructor-arg value=""4""/>
            <constructor-arg value=""0""/>
            <constructor-arg value=""4""/>
        </bean>
        <bean class=""io.netty.handler.codec.string.StringDecoder""/>
    </util:list>

    <util:list id=""encoders"" list-class=""java.util.LinkedList"">
        <bean class=""io.netty.handler.codec.LengthFieldPrepender"">
            <constructor-arg value=""4""/>
        </bean>
        <bean class=""io.netty.handler.codec.string.StringEncoder""/>
    </util:list>

    <bean id=""length-encoder"" class=""io.netty.handler.codec.LengthFieldPrepender"">
        <constructor-arg value=""4""/>
    </bean>
    <bean id=""string-encoder"" class=""io.netty.handler.codec.string.StringEncoder""/>

    <bean id=""length-decoder"" class=""org.apache.camel.component.netty.ChannelHandlerFactories"" factory-method=""newLengthFieldBasedFrameDecoder"">
        <constructor-arg value=""1048576""/>
        <constructor-arg value=""0""/>
        <constructor-arg value=""4""/>
        <constructor-arg value=""0""/>
        <constructor-arg value=""4""/>
    </bean>
    <bean id=""string-decoder"" class=""io.netty.handler.codec.string.StringDecoder""/>
----

The bean names can then be used in netty endpoint definitions either as
a comma separated list or contained in a List e.g.

[source,java]
----
 from(""direct:multiple-codec"").to(""netty:tcp://0.0.0.0:{{port}}?encoders=#encoders&sync=false"");

 from(""netty:tcp://0.0.0.0:{{port}}?decoders=#length-decoder,#string-decoder&sync=false"").to(""mock:multiple-codec"");
----

or via XML.

[source,xml]
----
<camelContext id=""multiple-netty-codecs-context"" xmlns=""http://camel.apache.org/schema/spring"">
    <route>
        <from uri=""direct:multiple-codec""/>
        <to uri=""netty:tcp://0.0.0.0:5150?encoders=#encoders&amp;sync=false""/>
    </route>
    <route>
        <from uri=""netty:tcp://0.0.0.0:5150?decoders=#length-decoder,#string-decoder&amp;sync=false""/>
        <to uri=""mock:multiple-codec""/>
    </route>
</camelContext>
----

== Closing Channel When Complete

When acting as a server you sometimes want to close the channel when,
for example, a client conversion is finished. +
 You can do this by simply setting the endpoint option
`disconnect=true`.

However you can also instruct Camel on a per message basis as follows. +
 To instruct Camel to close the channel, you should add a header with
the key `CamelNettyCloseChannelWhenComplete` set to a boolean `true`
value. +
 For instance, the example below will close the channel after it has
written the bye message back to the client:

[source,java]
----
from(""netty:tcp://0.0.0.0:8080"").process(new Processor() {
    public void process(Exchange exchange) throws Exception {
        String body = exchange.getIn().getBody(String.class);
        exchange.getOut().setBody(""Bye "" + body);
        // some condition which determines if we should close
        if (close) {
            exchange.getOut().setHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, true);
        }
    }
});
----

[[Netty-Addingcustomchannelpipelinefactoriestogaincompletecontroloveracreatedpipeline]]
Adding custom channel pipeline factories to gain complete control over a created pipeline

== Custom pipeline

Custom channel pipelines provide complete control to the user over the
handler/interceptor chain by inserting custom handler(s), encoder(s) &
decoder(s) without having to specify them in the Netty Endpoint URL in a
very simple way.

In order to add a custom pipeline, a custom channel pipeline factory
must be created and registered with the context via the context registry
(Registry, or the camel-spring ApplicationContextRegistry etc).

A custom pipeline factory must be constructed as follows

* A Producer linked channel pipeline factory must extend the abstract
class `ClientPipelineFactory`.
* A Consumer linked channel pipeline factory must extend the abstract
class `ServerInitializerFactory`.
* The classes should override the initChannel() method in order to
insert custom handler(s), encoder(s) and decoder(s). Not overriding the
`initChannel()` method creates a pipeline with no handlers, encoders or
decoders wired to the pipeline.

The example below shows how ServerInitializerFactory factory may be
created

=== Using custom pipeline factory

[source,java]
----
public class SampleServerInitializerFactory extends ServerInitializerFactory {
    private int maxLineSize = 1024;

    protected void initChannel(Channel ch) throws Exception {
        ChannelPipeline channelPipeline = ch.pipeline();

        channelPipeline.addLast(""encoder-SD"", new StringEncoder(CharsetUtil.UTF_8));
        channelPipeline.addLast(""decoder-DELIM"", new DelimiterBasedFrameDecoder(maxLineSize, true, Delimiters.lineDelimiter()));
        channelPipeline.addLast(""decoder-SD"", new StringDecoder(CharsetUtil.UTF_8));
        // here we add the default Camel ServerChannelHandler for the consumer, to allow Camel to route the message etc.
        channelPipeline.addLast(""handler"", new ServerChannelHandler(consumer));
    }
}
----

The custom channel pipeline factory can then be added to the registry
and instantiated/utilized on a camel route in the following way

[source,java]
----
Registry registry = camelContext.getRegistry();
ServerInitializerFactory factory = new TestServerInitializerFactory();
registry.bind(""spf"", factory);
context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty:tcp://0.0.0.0:5150?serverInitializerFactory=#spf""
      String return_string =
         ""When You Go Home, Tell Them Of Us And Say,""
         + ""For Your Tomorrow, We Gave Our Today."";

      from(netty_ssl_endpoint)
       .process(new Processor() {
          public void process(Exchange exchange) throws Exception {
            exchange.getOut().setBody(return_string);
          }
       }
  }
});
----

== Reusing Netty boss and worker thread pools

Netty has two kind of thread pools: boss and worker. By default each
Netty consumer and producer has their private thread pools. If you want
to reuse these thread pools among multiple consumers or producers then
the thread pools must be created and enlisted in the
Registry.

For example using Spring XML we can create a shared worker thread pool
using the `NettyWorkerPoolBuilder` with 2 worker threads as shown below:

[source,xml]
----
<!-- use the worker pool builder to help create the shared thread pool -->
<bean id=""poolBuilder"" class=""org.apache.camel.component.netty.NettyWorkerPoolBuilder"">
  <property name=""workerCount"" value=""2""/>
</bean>

<!-- the shared worker thread pool -->
<bean id=""sharedPool"" class=""org.jboss.netty.channel.socket.nio.WorkerPool""
      factory-bean=""poolBuilder"" factory-method=""build"" destroy-method=""shutdown"">
</bean>
----

[TIP]
====
For boss thread pool there is a
`org.apache.camel.component.netty.NettyServerBossPoolBuilder` builder
for Netty consumers, and a
`org.apache.camel.component.netty.NettyClientBossPoolBuilder` for the
Netty producers.
====

Then in the Camel routes we can refer to this worker pools by
configuring the `workerPool` option in the URI as shown below:

[source,xml]
----
<route>
  <from uri=""netty:tcp://0.0.0.0:5021?textline=true&amp;sync=true&amp;workerPool=#sharedPool&amp;usingExecutorService=false""/>
  <to uri=""log:result""/>
  ...
</route>
----

And if we have another route we can refer to the shared worker pool:

[source,xml]
----
<route>
  <from uri=""netty:tcp://0.0.0.0:5022?textline=true&amp;sync=true&amp;workerPool=#sharedPool&amp;usingExecutorService=false""/>
  <to uri=""log:result""/>
  ...
</route>
----

and so forth.

== Multiplexing concurrent messages over a single connection with request/reply

When using Netty for request/reply messaging via the netty producer then by default each
message is sent via a non-shared connection (pooled). This ensures that replies are
automatic being able to map to the correct request thread for further routing in Camel.
In other words correlation between request/reply messages happens out-of-the-box because
the replies comes back on the same connection that was used for sending the request;
and this connection is not shared with others. When the response comes back, the connection
is returned back to the connection pool, where it can be reused by others.

However if you want to multiplex concurrent request/responses on a single shared connection,
then you need to turn off the connection pooling by setting `producerPoolEnabled=false`.
Now this means there is a potential issue with interleaved responses if replies comes back out-of-order.
Therefore you need to have a correlation id in both the request and reply messages so you can properly
correlate the replies to the Camel callback that is responsible for continue processing the message in Camel.
To do this you need to implement `NettyCamelStateCorrelationManager` as correlation manager and configure
it via the `correlationManager=#myManager` option.

[NOTE]
====
We recommend extending the `TimeoutCorrelationManagerSupport` when you build custom correlation managers.
This provides support for timeout and other complexities you otherwise would need to implement as well.
====

You can find an example with the Apache Camel source code in the examples directory
under the `camel-example-netty-custom-correlation` directory.


include::camel-spring-boot::page$netty-starter.adoc[]
",12463,False,2334.5860328488197,median
"/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga  2006-2009
//
// 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)
//
// See http://www.boost.org/libs/intrusive for documentation.
//
/////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_INTRUSIVE_RBTREE_HPP
#define BOOST_INTRUSIVE_RBTREE_HPP

#include <boost/intrusive/detail/config_begin.hpp>
#include <algorithm>
#include <cstddef>
#include <functional>
#include <iterator>
#include <utility>

#include <boost/intrusive/detail/assert.hpp>
#include <boost/static_assert.hpp>
#include <boost/intrusive/intrusive_fwd.hpp>
#include <boost/intrusive/set_hook.hpp>
#include <boost/intrusive/detail/rbtree_node.hpp>
#include <boost/intrusive/detail/tree_node.hpp>
#include <boost/intrusive/detail/ebo_functor_holder.hpp>
#include <boost/intrusive/detail/mpl.hpp>
#include <boost/intrusive/detail/pointer_to_other.hpp>
#include <boost/intrusive/detail/clear_on_destructor_base.hpp>
#include <boost/intrusive/detail/function_detector.hpp>
#include <boost/intrusive/options.hpp>
#include <boost/intrusive/rbtree_algorithms.hpp>
#include <boost/intrusive/link_mode.hpp>
#include <boost/move/move.hpp>

namespace boost {
namespace intrusive {

/// @cond

template <class ValueTraits, class Compare, class SizeType, bool ConstantTimeSize>
struct setopt
{
   typedef ValueTraits  value_traits;
   typedef Compare      compare;
   typedef SizeType     size_type;
   static const bool constant_time_size = ConstantTimeSize;
};

template <class T>
struct set_defaults
   :  pack_options
      < none
      , base_hook<detail::default_set_hook>
      , constant_time_size<true>
      , size_type<std::size_t>
      , compare<std::less<T> >
      >::type
{};

/// @endcond

//! The class template rbtree is an intrusive red-black tree container, that
//! is used to construct intrusive set and multiset containers. The no-throw 
//! guarantee holds only, if the value_compare object 
//! doesn't throw.
//!
//! The template parameter \\c T is the type to be managed by the container.
//! The user can specify additional options and if no options are provided
//! default options are used.
//!
//! The container supports the following options:
//! \\c base_hook<>/member_hook<>/value_traits<>,
//! \\c constant_time_size<>, \\c size_type<> and
//! \\c compare<>.
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
template<class T, class ...Options>
#else
template<class Config>
#endif
class rbtree_impl
   :  private detail::clear_on_destructor_base<rbtree_impl<Config> >
{
   template<class C> friend class detail::clear_on_destructor_base;
   public:
   typedef typename Config::value_traits                             value_traits;
   /// @cond
   static const bool external_value_traits =
      detail::external_value_traits_is_true<value_traits>::value;
   typedef typename detail::eval_if_c
      < external_value_traits
      , detail::eval_value_traits<value_traits>
      , detail::identity<value_traits>
      >::type                                                        real_value_traits;
   /// @endcond
   typedef typename real_value_traits::pointer                       pointer;
   typedef typename real_value_traits::const_pointer                 const_pointer;
   typedef typename std::iterator_traits<pointer>::value_type        value_type;
   typedef value_type                                                key_type;
   typedef typename std::iterator_traits<pointer>::reference         reference;
   typedef typename std::iterator_traits<const_pointer>::reference   const_reference;
   typedef typename std::iterator_traits<pointer>::difference_type   difference_type;
   typedef typename Config::size_type                                size_type;
   typedef typename Config::compare                                  value_compare;
   typedef value_compare                                             key_compare;
   typedef tree_iterator<rbtree_impl, false>                         iterator;
   typedef tree_iterator<rbtree_impl, true>                          const_iterator;
   typedef std::reverse_iterator<iterator>                           reverse_iterator;
   typedef std::reverse_iterator<const_iterator>                     const_reverse_iterator;
   typedef typename real_value_traits::node_traits                   node_traits;
   typedef typename node_traits::node                                node;
   typedef typename node_traits::node_ptr                            node_ptr;
   typedef typename node_traits::const_node_ptr                      const_node_ptr;
   typedef rbtree_algorithms<node_traits>                            node_algorithms;

   static const bool constant_time_size = Config::constant_time_size;
   static const bool stateful_value_traits = detail::is_stateful_value_traits<real_value_traits>::value;
   /// @cond
   private:
   typedef detail::size_holder<constant_time_size, size_type>        size_traits;

   //noncopyable
   BOOST_MOVABLE_BUT_NOT_COPYABLE(rbtree_impl)

   enum { safemode_or_autounlink  = 
            (int)real_value_traits::link_mode == (int)auto_unlink   ||
            (int)real_value_traits::link_mode == (int)safe_link     };

   //Constant-time size is incompatible with auto-unlink hooks!
   BOOST_STATIC_ASSERT(!(constant_time_size && ((int)real_value_traits::link_mode == (int)auto_unlink)));

   struct header_plus_size : public size_traits
   {  node header_;  };

   struct node_plus_pred_t : public detail::ebo_functor_holder<value_compare>
   {
      node_plus_pred_t(const value_compare &comp)
         :  detail::ebo_functor_holder<value_compare>(comp)
      {}
      header_plus_size header_plus_size_;
   };

   struct data_t : public rbtree_impl::value_traits
   {
      typedef typename rbtree_impl::value_traits value_traits;
      data_t(const value_compare & comp, const value_traits &val_traits)
         :  value_traits(val_traits), node_plus_pred_(comp)
      {}
      node_plus_pred_t node_plus_pred_;
   } data_;

   const value_compare &priv_comp() const
   {  return data_.node_plus_pred_.get();  }

   value_compare &priv_comp()
   {  return data_.node_plus_pred_.get();  }

   const value_traits &priv_value_traits() const
   {  return data_;  }

   value_traits &priv_value_traits()
   {  return data_;  }

   const node &priv_header() const
   {  return data_.node_plus_pred_.header_plus_size_.header_;  }

   node &priv_header()
   {  return data_.node_plus_pred_.header_plus_size_.header_;  }

   static node_ptr uncast(const_node_ptr ptr)
   {
      return node_ptr(const_cast<node*>(detail::boost_intrusive_get_pointer(ptr)));
//iG pending return node_ptr(boost::const_pointer_cast<node>(ptr));
   }

   size_traits &priv_size_traits()
   {  return data_.node_plus_pred_.header_plus_size_;  }

   const size_traits &priv_size_traits() const
   {  return data_.node_plus_pred_.header_plus_size_;  }

   const real_value_traits &get_real_value_traits(detail::bool_<false>) const
   {  return data_;  }

   const real_value_traits &get_real_value_traits(detail::bool_<true>) const
   {  return data_.get_value_traits(*this);  }

   real_value_traits &get_real_value_traits(detail::bool_<false>)
   {  return data_;  }

   real_value_traits &get_real_value_traits(detail::bool_<true>)
   {  return data_.get_value_traits(*this);  }

   protected:
   value_compare &prot_comp()
   {  return priv_comp(); }

   const node &prot_header_node() const
   {  return priv_header(); }

   node &prot_header_node()
   {  return priv_header(); }

   void prot_set_size(size_type s)
   {  this->priv_size_traits().set_size(s);  }

   /// @endcond

   public:

   const real_value_traits &get_real_value_traits() const
   {  return this->get_real_value_traits(detail::bool_<external_value_traits>());  }

   real_value_traits &get_real_value_traits()
   {  return this->get_real_value_traits(detail::bool_<external_value_traits>());  }

   typedef typename node_algorithms::insert_commit_data insert_commit_data;

   //! <b>Effects</b>: Constructs an empty tree. 
   //!   
   //! <b>Complexity</b>: Constant. 
   //! 
   //! <b>Throws</b>: If value_traits::node_traits::node
   //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks)
   //!   or the copy constructorof the value_compare object throws. Basic guarantee.
   rbtree_impl( const value_compare &cmp = value_compare()
              , const value_traits &v_traits = value_traits()) 
      :  data_(cmp, v_traits)
   {  
      node_algorithms::init_header(&priv_header());  
      this->priv_size_traits().set_size(size_type(0));
   }

   //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type.
   //!   cmp must be a comparison function that induces a strict weak ordering.
   //!
   //! <b>Effects</b>: Constructs an empty tree and inserts elements from
   //!   [b, e).
   //!
   //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using
   //!   comp and otherwise N * log N, where N is the distance between first and last.
   //! 
   //! <b>Throws</b>: If value_traits::node_traits::node
   //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks)
   //!   or the copy constructor/operator() of the value_compare object throws. Basic guarantee.
   template<class Iterator>
   rbtree_impl( bool unique, Iterator b, Iterator e
              , const value_compare &cmp     = value_compare()
              , const value_traits &v_traits = value_traits())
      : data_(cmp, v_traits)
   {
      node_algorithms::init_header(&priv_header());
      this->priv_size_traits().set_size(size_type(0));
      if(unique)
         this->insert_unique(b, e);
      else
         this->insert_equal(b, e);
   }

   //! <b>Effects</b>: to-do
   //!   
   rbtree_impl(BOOST_RV_REF(rbtree_impl) x)
      : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits()))
   {
      node_algorithms::init_header(&priv_header());  
      this->priv_size_traits().set_size(size_type(0));
      this->swap(x);
   }

   //! <b>Effects</b>: to-do
   //!   
   rbtree_impl& operator=(BOOST_RV_REF(rbtree_impl) x) 
   {  this->swap(x); return *this;  }

   //! <b>Effects</b>: Detaches all elements from this. The objects in the set 
   //!   are not deleted (i.e. no destructors are called), but the nodes according to 
   //!   the value_traits template parameter are reinitialized and thus can be reused. 
   //! 
   //! <b>Complexity</b>: Linear to elements contained in *this. 
   //! 
   //! <b>Throws</b>: Nothing.
   ~rbtree_impl() 
   {}

   //! <b>Effects</b>: Returns an iterator pointing to the beginning of the tree.
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   iterator begin()
   {  return iterator (node_traits::get_left(node_ptr(&priv_header())), this);   }

   //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the tree.
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   const_iterator begin() const
   {  return cbegin();   }

   //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the tree.
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   const_iterator cbegin() const
   {  return const_iterator (node_traits::get_left(const_node_ptr(&priv_header())), this);   }

   //! <b>Effects</b>: Returns an iterator pointing to the end of the tree.
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   iterator end()
   {  return iterator (node_ptr(&priv_header()), this);  }

   //! <b>Effects</b>: Returns a const_iterator pointing to the end of the tree.
   //!
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   const_iterator end() const
   {  return cend();  }

   //! <b>Effects</b>: Returns a const_iterator pointing to the end of the tree.
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   const_iterator cend() const
   {  return const_iterator (uncast(const_node_ptr(&priv_header())), this);  }

   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning of the
   //!    reversed tree.
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   reverse_iterator rbegin()
   {  return reverse_iterator(end());  }

   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
   //!    of the reversed tree.
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   const_reverse_iterator rbegin() const
   {  return const_reverse_iterator(end());  }

   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
   //!    of the reversed tree.
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   const_reverse_iterator crbegin() const
   {  return const_reverse_iterator(end());  }

   //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
   //!    of the reversed tree.
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   reverse_iterator rend()
   {  return reverse_iterator(begin());   }

   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
   //!    of the reversed tree.
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   const_reverse_iterator rend() const
   {  return const_reverse_iterator(begin());   }

   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
   //!    of the reversed tree.
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   const_reverse_iterator crend() const
   {  return const_reverse_iterator(begin());   }

   //! <b>Precondition</b>: end_iterator must be a valid end iterator
   //!   of rbtree.
   //! 
   //! <b>Effects</b>: Returns a const reference to the rbtree associated to the end iterator
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Complexity</b>: Constant.
   static rbtree_impl &container_from_end_iterator(iterator end_iterator)
   {  return priv_container_from_end_iterator(end_iterator);   }

   //! <b>Precondition</b>: end_iterator must be a valid end const_iterator
   //!   of rbtree.
   //! 
   //! <b>Effects</b>: Returns a const reference to the rbtree associated to the iterator
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Complexity</b>: Constant.
   static const rbtree_impl &container_from_end_iterator(const_iterator end_iterator)
   {  return priv_container_from_end_iterator(end_iterator);   }

   //! <b>Precondition</b>: it must be a valid iterator
   //!   of rbtree.
   //! 
   //! <b>Effects</b>: Returns a const reference to the tree associated to the iterator
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Complexity</b>: Logarithmic.
   static rbtree_impl &container_from_iterator(iterator it)
   {  return priv_container_from_iterator(it);   }

   //! <b>Precondition</b>: it must be a valid end const_iterator
   //!   of rbtree.
   //! 
   //! <b>Effects</b>: Returns a const reference to the tree associated to the end iterator
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Complexity</b>: Logarithmic.
   static const rbtree_impl &container_from_iterator(const_iterator it)
   {  return priv_container_from_iterator(it);   }

   //! <b>Effects</b>: Returns the value_compare object used by the tree.
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: If value_compare copy-constructor throws.
   value_compare value_comp() const
   {  return priv_comp();   }

   //! <b>Effects</b>: Returns true if the container is empty.
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   bool empty() const
   {  return node_algorithms::unique(const_node_ptr(&priv_header()));   }

   //! <b>Effects</b>: Returns the number of elements stored in the tree.
   //! 
   //! <b>Complexity</b>: Linear to elements contained in *this
   //!   if constant-time size option is disabled. Constant time otherwise.
   //! 
   //! <b>Throws</b>: Nothing.
   size_type size() const
   {
      if(constant_time_size)
         return this->priv_size_traits().get_size();
      else{
         return (size_type)node_algorithms::size(const_node_ptr(&priv_header()));
      }
   }

   //! <b>Effects</b>: Swaps the contents of two rbtrees.
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: If the comparison functor's swap call throws.
   void swap(rbtree_impl& other)
   {
      //This can throw
      using std::swap;
      swap(priv_comp(), priv_comp());
      //These can't throw
      node_algorithms::swap_tree(node_ptr(&priv_header()), node_ptr(&other.priv_header()));
      if(constant_time_size){
         size_type backup = this->priv_size_traits().get_size();
         this->priv_size_traits().set_size(other.priv_size_traits().get_size());
         other.priv_size_traits().set_size(backup);
      }
   }

   //! <b>Requires</b>: value must be an lvalue
   //! 
   //! <b>Effects</b>: Inserts value into the tree before the upper bound.
   //! 
   //! <b>Complexity</b>: Average complexity for insert element is at
   //!   most logarithmic.
   //! 
   //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee.
   //! 
   //! <b>Note</b>: Does not affect the validity of iterators and references.
   //!   No copy-constructors are called.
   iterator insert_equal(reference value)
   {
      detail::key_nodeptr_comp<value_compare, rbtree_impl>
         key_node_comp(priv_comp(), this);
      node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
      iterator ret(node_algorithms::insert_equal_upper_bound
         (node_ptr(&priv_header()), to_insert, key_node_comp), this);
      this->priv_size_traits().increment();
      return ret;
   }

   //! <b>Requires</b>: value must be an lvalue, and ""hint"" must be
   //!   a valid iterator.
   //! 
   //! <b>Effects</b>: Inserts x into the tree, using ""hint"" as a hint to
   //!   where it will be inserted. If ""hint"" is the upper_bound
   //!   the insertion takes constant time (two comparisons in the worst case)
   //! 
   //! <b>Complexity</b>: Logarithmic in general, but it is amortized
   //!   constant time if t is inserted immediately before hint.
   //! 
   //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee.
   //! 
   //! <b>Note</b>: Does not affect the validity of iterators and references.
   //!   No copy-constructors are called.
   iterator insert_equal(const_iterator hint, reference value)
   {
      detail::key_nodeptr_comp<value_compare, rbtree_impl>
         key_node_comp(priv_comp(), this);
      node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
      iterator ret(node_algorithms::insert_equal
         (node_ptr(&priv_header()), hint.pointed_node(), to_insert, key_node_comp), this);
      this->priv_size_traits().increment();
      return ret;
   }

   //! <b>Requires</b>: Dereferencing iterator must yield an lvalue 
   //!   of type value_type.
   //! 
   //! <b>Effects</b>: Inserts a each element of a range into the tree
   //!   before the upper bound of the key of each element.
   //! 
   //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the
   //!   size of the range. However, it is linear in N if the range is already sorted
   //!   by value_comp().
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: Does not affect the validity of iterators and references.
   //!   No copy-constructors are called.
   template<class Iterator>
   void insert_equal(Iterator b, Iterator e)
   {
      iterator iend(this->end());
      for (; b != e; ++b)
         this->insert_equal(iend, *b);
   }

   //! <b>Requires</b>: value must be an lvalue
   //! 
   //! <b>Effects</b>: Inserts value into the tree if the value
   //!   is not already present.
   //! 
   //! <b>Complexity</b>: Average complexity for insert element is at
   //!   most logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: Does not affect the validity of iterators and references.
   //!   No copy-constructors are called.
   std::pair<iterator, bool> insert_unique(reference value)
   {
      insert_commit_data commit_data;
      std::pair<iterator, bool> ret = insert_unique_check(value, priv_comp(), commit_data);
      if(!ret.second)
         return ret;
      return std::pair<iterator, bool> (insert_unique_commit(value, commit_data), true);
   }

   //! <b>Requires</b>: value must be an lvalue, and ""hint"" must be
   //!   a valid iterator
   //! 
   //! <b>Effects</b>: Tries to insert x into the tree, using ""hint"" as a hint
   //!   to where it will be inserted.
   //! 
   //! <b>Complexity</b>: Logarithmic in general, but it is amortized
   //!   constant time (two comparisons in the worst case)
   //!   if t is inserted immediately before hint.
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: Does not affect the validity of iterators and references.
   //!   No copy-constructors are called.
   iterator insert_unique(const_iterator hint, reference value)
   {
      insert_commit_data commit_data;
      std::pair<iterator, bool> ret = insert_unique_check(hint, value, priv_comp(), commit_data);
      if(!ret.second)
         return ret.first;
      return insert_unique_commit(value, commit_data);
   }

   //! <b>Requires</b>: Dereferencing iterator must yield an lvalue 
   //!   of type value_type.
   //! 
   //! <b>Effects</b>: Tries to insert each element of a range into the tree.
   //! 
   //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the 
   //!   size of the range. However, it is linear in N if the range is already sorted 
   //!   by value_comp().
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: Does not affect the validity of iterators and references.
   //!   No copy-constructors are called.
   template<class Iterator>
   void insert_unique(Iterator b, Iterator e)
   {
      if(this->empty()){
         iterator iend(this->end());
         for (; b != e; ++b)
            this->insert_unique(iend, *b);
      }
      else{
         for (; b != e; ++b)
            this->insert_unique(*b);
      }
   }

   //! <b>Requires</b>: key_value_comp must be a comparison function that induces 
   //!   the same strict weak ordering as value_compare. The difference is that
   //!   key_value_comp compares an arbitrary key with the contained values.
   //! 
   //! <b>Effects</b>: Checks if a value can be inserted in the container, using
   //!   a user provided key instead of the value itself.
   //!
   //! <b>Returns</b>: If there is an equivalent value
   //!   returns a pair containing an iterator to the already present value
   //!   and false. If the value can be inserted returns true in the returned
   //!   pair boolean and fills ""commit_data"" that is meant to be used with
   //!   the ""insert_commit"" function.
   //! 
   //! <b>Complexity</b>: Average complexity is at most logarithmic.
   //!
   //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee.
   //! 
   //! <b>Notes</b>: This function is used to improve performance when constructing
   //!   a value_type is expensive: if there is an equivalent value
   //!   the constructed object must be discarded. Many times, the part of the
   //!   node that is used to impose the order is much cheaper to construct
   //!   than the value_type and this function offers the possibility to use that 
   //!   part to check if the insertion will be successful.
   //!
   //!   If the check is successful, the user can construct the value_type and use
   //!   ""insert_commit"" to insert the object in constant-time. This gives a total
   //!   logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)).
   //!
   //!   ""commit_data"" remains valid for a subsequent ""insert_commit"" only if no more
   //!   objects are inserted or erased from the container.
   template<class KeyType, class KeyValueCompare>
   std::pair<iterator, bool> insert_unique_check
      (const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data)
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         comp(key_value_comp, this);
      std::pair<node_ptr, bool> ret = 
         (node_algorithms::insert_unique_check
            (node_ptr(&priv_header()), key, comp, commit_data));
      return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
   }

   //! <b>Requires</b>: key_value_comp must be a comparison function that induces 
   //!   the same strict weak ordering as value_compare. The difference is that
   //!   key_value_comp compares an arbitrary key with the contained values.
   //! 
   //! <b>Effects</b>: Checks if a value can be inserted in the container, using
   //!   a user provided key instead of the value itself, using ""hint"" 
   //!   as a hint to where it will be inserted.
   //!
   //! <b>Returns</b>: If there is an equivalent value
   //!   returns a pair containing an iterator to the already present value
   //!   and false. If the value can be inserted returns true in the returned
   //!   pair boolean and fills ""commit_data"" that is meant to be used with
   //!   the ""insert_commit"" function.
   //! 
   //! <b>Complexity</b>: Logarithmic in general, but it's amortized
   //!   constant time if t is inserted immediately before hint.
   //!
   //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee.
   //! 
   //! <b>Notes</b>: This function is used to improve performance when constructing
   //!   a value_type is expensive: if there is an equivalent value
   //!   the constructed object must be discarded. Many times, the part of the
   //!   constructing that is used to impose the order is much cheaper to construct
   //!   than the value_type and this function offers the possibility to use that key 
   //!   to check if the insertion will be successful.
   //!
   //!   If the check is successful, the user can construct the value_type and use
   //!   ""insert_commit"" to insert the object in constant-time. This can give a total
   //!   constant-time complexity to the insertion: check(O(1)) + commit(O(1)).
   //!   
   //!   ""commit_data"" remains valid for a subsequent ""insert_commit"" only if no more
   //!   objects are inserted or erased from the container.
   template<class KeyType, class KeyValueCompare>
   std::pair<iterator, bool> insert_unique_check
      (const_iterator hint, const KeyType &key
      ,KeyValueCompare key_value_comp, insert_commit_data &commit_data)
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         comp(key_value_comp, this);
      std::pair<node_ptr, bool> ret = 
         (node_algorithms::insert_unique_check
            (node_ptr(&priv_header()), hint.pointed_node(), key, comp, commit_data));
      return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
   }

   //! <b>Requires</b>: value must be an lvalue of type value_type. commit_data
   //!   must have been obtained from a previous call to ""insert_check"".
   //!   No objects should have been inserted or erased from the container between
   //!   the ""insert_check"" that filled ""commit_data"" and the call to ""insert_commit"".
   //! 
   //! <b>Effects</b>: Inserts the value in the avl_set using the information obtained
   //!   from the ""commit_data"" that a previous ""insert_check"" filled.
   //!
   //! <b>Returns</b>: An iterator to the newly inserted object.
   //! 
   //! <b>Complexity</b>: Constant time.
   //!
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Notes</b>: This function has only sense if a ""insert_check"" has been
   //!   previously executed to fill ""commit_data"". No value should be inserted or
   //!   erased between the ""insert_check"" and ""insert_commit"" calls.
   iterator insert_unique_commit(reference value, const insert_commit_data &commit_data)
   {
      node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
      node_algorithms::insert_unique_commit
               (node_ptr(&priv_header()), to_insert, commit_data);
      this->priv_size_traits().increment();
      return iterator(to_insert, this);
   }

   //! <b>Requires</b>: value must be an lvalue, ""pos"" must be
   //!   a valid iterator (or end) and must be the succesor of value
   //!   once inserted according to the predicate
   //!
   //! <b>Effects</b>: Inserts x into the tree before ""pos"".
   //! 
   //! <b>Complexity</b>: Constant time.
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: This function does not check preconditions so if ""pos"" is not
   //! the successor of ""value"" tree ordering invariant will be broken.
   //! This is a low-level function to be used only for performance reasons
   //! by advanced users.
   iterator insert_before(const_iterator pos, reference value)
   {
      node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
      this->priv_size_traits().increment();
      return iterator(node_algorithms::insert_before
         (node_ptr(&priv_header()), pos.pointed_node(), to_insert), this);
   }

   //! <b>Requires</b>: value must be an lvalue, and it must be no less
   //!   than the greatest inserted key
   //!
   //! <b>Effects</b>: Inserts x into the tree in the last position.
   //! 
   //! <b>Complexity</b>: Constant time.
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: This function does not check preconditions so if value is
   //!   less than the greatest inserted key tree ordering invariant will be broken.
   //!   This function is slightly more efficient than using ""insert_before"".
   //!   This is a low-level function to be used only for performance reasons
   //!   by advanced users.
   void push_back(reference value)
   {
      node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
      this->priv_size_traits().increment();
      node_algorithms::push_back(node_ptr(&priv_header()), to_insert);
   }

   //! <b>Requires</b>: value must be an lvalue, and it must be no greater
   //!   than the minimum inserted key
   //!
   //! <b>Effects</b>: Inserts x into the tree in the first position.
   //! 
   //! <b>Complexity</b>: Constant time.
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: This function does not check preconditions so if value is
   //!   greater than the minimum inserted key tree ordering invariant will be broken.
   //!   This function is slightly more efficient than using ""insert_before"".
   //!   This is a low-level function to be used only for performance reasons
   //!   by advanced users.
   void push_front(reference value)
   {
      node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
      this->priv_size_traits().increment();
      node_algorithms::push_front(node_ptr(&priv_header()), to_insert);
   }

   //! <b>Effects</b>: Erases the element pointed to by pos. 
   //! 
   //! <b>Complexity</b>: Average complexity for erase element is constant time. 
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: Invalidates the iterators (but not the references)
   //!    to the erased elements. No destructors are called.
   iterator erase(const_iterator i)
   {
      const_iterator ret(i);
      ++ret;
      node_ptr to_erase(i.pointed_node());
      if(safemode_or_autounlink)
         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!node_algorithms::unique(to_erase));
      node_algorithms::erase(&priv_header(), to_erase);
      this->priv_size_traits().decrement();
      if(safemode_or_autounlink)
         node_algorithms::init(to_erase);
      return ret.unconst();
   }

   //! <b>Effects</b>: Erases the range pointed to by b end e. 
   //! 
   //! <b>Complexity</b>: Average complexity for erase range is at most 
   //!   O(log(size() + N)), where N is the number of elements in the range.
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: Invalidates the iterators (but not the references)
   //!    to the erased elements. No destructors are called.
   iterator erase(const_iterator b, const_iterator e)
   {  size_type n;   return private_erase(b, e, n);   }

   //! <b>Effects</b>: Erases all the elements with the given value.
   //! 
   //! <b>Returns</b>: The number of erased elements.
   //! 
   //! <b>Complexity</b>: O(log(size() + N).
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: Invalidates the iterators (but not the references)
   //!    to the erased elements. No destructors are called.
   size_type erase(const_reference value)
   {  return this->erase(value, priv_comp());   }

   //! <b>Effects</b>: Erases all the elements with the given key.
   //!   according to the comparison functor ""comp"".
   //!
   //! <b>Returns</b>: The number of erased elements.
   //! 
   //! <b>Complexity</b>: O(log(size() + N).
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: Invalidates the iterators (but not the references)
   //!    to the erased elements. No destructors are called.
   template<class KeyType, class KeyValueCompare>
   size_type erase(const KeyType& key, KeyValueCompare comp
                  /// @cond
                  , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0
                  /// @endcond
                  )
   {
      std::pair<iterator,iterator> p = this->equal_range(key, comp);
      size_type n;
      private_erase(p.first, p.second, n);
      return n;
   }

   //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
   //!
   //! <b>Effects</b>: Erases the element pointed to by pos. 
   //!   Disposer::operator()(pointer) is called for the removed element.
   //! 
   //! <b>Complexity</b>: Average complexity for erase element is constant time. 
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: Invalidates the iterators 
   //!    to the erased elements.
   template<class Disposer>
   iterator erase_and_dispose(const_iterator i, Disposer disposer)
   {
      node_ptr to_erase(i.pointed_node());
      iterator ret(this->erase(i));
      disposer(get_real_value_traits().to_value_ptr(to_erase));
      return ret;
   }

   #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
   template<class Disposer>
   iterator erase_and_dispose(iterator i, Disposer disposer)
   {  return this->erase_and_dispose(const_iterator(i), disposer);   }
   #endif

   //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
   //!
   //! <b>Effects</b>: Erases all the elements with the given value.
   //!   Disposer::operator()(pointer) is called for the removed elements.
   //! 
   //! <b>Returns</b>: The number of erased elements.
   //! 
   //! <b>Complexity</b>: O(log(size() + N).
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: Invalidates the iterators (but not the references)
   //!    to the erased elements. No destructors are called.
   template<class Disposer>
   size_type erase_and_dispose(const_reference value, Disposer disposer)
   {
      std::pair<iterator,iterator> p = this->equal_range(value);
      size_type n;
      private_erase(p.first, p.second, n, disposer);
      return n;
   }

   //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
   //!
   //! <b>Effects</b>: Erases the range pointed to by b end e.
   //!   Disposer::operator()(pointer) is called for the removed elements.
   //! 
   //! <b>Complexity</b>: Average complexity for erase range is at most 
   //!   O(log(size() + N)), where N is the number of elements in the range.
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: Invalidates the iterators
   //!    to the erased elements.
   template<class Disposer>
   iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer)
   {  size_type n;   return private_erase(b, e, n, disposer);   }

   //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
   //!
   //! <b>Effects</b>: Erases all the elements with the given key.
   //!   according to the comparison functor ""comp"".
   //!   Disposer::operator()(pointer) is called for the removed elements.
   //!
   //! <b>Returns</b>: The number of erased elements.
   //! 
   //! <b>Complexity</b>: O(log(size() + N).
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: Invalidates the iterators
   //!    to the erased elements.
   template<class KeyType, class KeyValueCompare, class Disposer>
   size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer
                  /// @cond
                  , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0
                  /// @endcond
                  )
   {
      std::pair<iterator,iterator> p = this->equal_range(key, comp);
      size_type n;
      private_erase(p.first, p.second, n, disposer);
      return n;
   }

   //! <b>Effects</b>: Erases all of the elements. 
   //! 
   //! <b>Complexity</b>: Linear to the number of elements on the container.
   //!   if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: Invalidates the iterators (but not the references)
   //!    to the erased elements. No destructors are called.
   void clear()
   {
      if(safemode_or_autounlink){
         this->clear_and_dispose(detail::null_disposer());
      }
      else{
         node_algorithms::init_header(&priv_header());
         this->priv_size_traits().set_size(0);
      }
   }

   //! <b>Effects</b>: Erases all of the elements calling disposer(p) for
   //!   each node to be erased.
   //! <b>Complexity</b>: Average complexity for is at most O(log(size() + N)),
   //!   where N is the number of elements in the container.
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: Invalidates the iterators (but not the references)
   //!    to the erased elements. Calls N times to disposer functor.
   template<class Disposer>
   void clear_and_dispose(Disposer disposer)
   {
      node_algorithms::clear_and_dispose(node_ptr(&priv_header())
         , detail::node_disposer<Disposer, rbtree_impl>(disposer, this));
      node_algorithms::init_header(&priv_header());
      this->priv_size_traits().set_size(0);
   }

   //! <b>Effects</b>: Returns the number of contained elements with the given value
   //! 
   //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal
   //!   to number of objects with the given value.
   //! 
   //! <b>Throws</b>: Nothing.
   size_type count(const_reference value) const
   {  return this->count(value, priv_comp());   }

   //! <b>Effects</b>: Returns the number of contained elements with the given key
   //! 
   //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal
   //!   to number of objects with the given key.
   //! 
   //! <b>Throws</b>: Nothing.
   template<class KeyType, class KeyValueCompare>
   size_type count(const KeyType &key, KeyValueCompare comp) const
   {
      std::pair<const_iterator, const_iterator> ret = this->equal_range(key, comp);
      return std::distance(ret.first, ret.second);
   }

   //! <b>Effects</b>: Returns an iterator to the first element whose
   //!   key is not less than k or end() if that element does not exist.
   //! 
   //! <b>Complexity</b>: Logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   iterator lower_bound(const_reference value)
   {  return this->lower_bound(value, priv_comp());   }

   //! <b>Effects</b>: Returns an iterator to the first element whose
   //!   key is not less than k or end() if that element does not exist.
   //! 
   //! <b>Complexity</b>: Logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   const_iterator lower_bound(const_reference value) const
   {  return this->lower_bound(value, priv_comp());   }

   //! <b>Effects</b>: Returns an iterator to the first element whose
   //!   key is not less than k or end() if that element does not exist.
   //! 
   //! <b>Complexity</b>: Logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   template<class KeyType, class KeyValueCompare>
   iterator lower_bound(const KeyType &key, KeyValueCompare comp)
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      return iterator(node_algorithms::lower_bound
         (const_node_ptr(&priv_header()), key, key_node_comp), this);
   }

   //! <b>Effects</b>: Returns a const iterator to the first element whose
   //!   key is not less than k or end() if that element does not exist.
   //! 
   //! <b>Complexity</b>: Logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   template<class KeyType, class KeyValueCompare>
   const_iterator lower_bound(const KeyType &key, KeyValueCompare comp) const
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      return const_iterator(node_algorithms::lower_bound
         (const_node_ptr(&priv_header()), key, key_node_comp), this);
   }

   //! <b>Effects</b>: Returns an iterator to the first element whose
   //!   key is greater than k or end() if that element does not exist.
   //! 
   //! <b>Complexity</b>: Logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   iterator upper_bound(const_reference value)
   {  return this->upper_bound(value, priv_comp());   }

   //! <b>Effects</b>: Returns an iterator to the first element whose
   //!   key is greater than k according to comp or end() if that element
   //!   does not exist.
   //!
   //! <b>Complexity</b>: Logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   template<class KeyType, class KeyValueCompare>
   iterator upper_bound(const KeyType &key, KeyValueCompare comp)
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      return iterator(node_algorithms::upper_bound
         (const_node_ptr(&priv_header()), key, key_node_comp), this);
   }

   //! <b>Effects</b>: Returns an iterator to the first element whose
   //!   key is greater than k or end() if that element does not exist.
   //! 
   //! <b>Complexity</b>: Logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   const_iterator upper_bound(const_reference value) const
   {  return this->upper_bound(value, priv_comp());   }

   //! <b>Effects</b>: Returns an iterator to the first element whose
   //!   key is greater than k according to comp or end() if that element
   //!   does not exist.
   //!
   //! <b>Complexity</b>: Logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   template<class KeyType, class KeyValueCompare>
   const_iterator upper_bound(const KeyType &key, KeyValueCompare comp) const
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      return const_iterator(node_algorithms::upper_bound
         (const_node_ptr(&priv_header()), key, key_node_comp), this);
   }

   //! <b>Effects</b>: Finds an iterator to the first element whose key is 
   //!   k or end() if that element does not exist.
   //!
   //! <b>Complexity</b>: Logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   iterator find(const_reference value)
   {  return this->find(value, priv_comp()); }

   //! <b>Effects</b>: Finds an iterator to the first element whose key is 
   //!   k or end() if that element does not exist.
   //!
   //! <b>Complexity</b>: Logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   template<class KeyType, class KeyValueCompare>
   iterator find(const KeyType &key, KeyValueCompare comp)
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      return iterator
         (node_algorithms::find(const_node_ptr(&priv_header()), key, key_node_comp), this);
   }

   //! <b>Effects</b>: Finds a const_iterator to the first element whose key is 
   //!   k or end() if that element does not exist.
   //! 
   //! <b>Complexity</b>: Logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   const_iterator find(const_reference value) const
   {  return this->find(value, priv_comp()); }

   //! <b>Effects</b>: Finds a const_iterator to the first element whose key is 
   //!   k or end() if that element does not exist.
   //! 
   //! <b>Complexity</b>: Logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   template<class KeyType, class KeyValueCompare>
   const_iterator find(const KeyType &key, KeyValueCompare comp) const
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      return const_iterator
         (node_algorithms::find(const_node_ptr(&priv_header()), key, key_node_comp), this);
   }

   //! <b>Effects</b>: Finds a range containing all elements whose key is k or
   //!   an empty range that indicates the position where those elements would be
   //!   if they there is no elements with key k.
   //! 
   //! <b>Complexity</b>: Logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   std::pair<iterator,iterator> equal_range(const_reference value)
   {  return this->equal_range(value, priv_comp());   }

   //! <b>Effects</b>: Finds a range containing all elements whose key is k or
   //!   an empty range that indicates the position where those elements would be
   //!   if they there is no elements with key k.
   //! 
   //! <b>Complexity</b>: Logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   template<class KeyType, class KeyValueCompare>
   std::pair<iterator,iterator> equal_range(const KeyType &key, KeyValueCompare comp)
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      std::pair<node_ptr, node_ptr> ret
         (node_algorithms::equal_range(const_node_ptr(&priv_header()), key, key_node_comp));
      return std::pair<iterator, iterator>(iterator(ret.first, this), iterator(ret.second, this));
   }

   //! <b>Effects</b>: Finds a range containing all elements whose key is k or
   //!   an empty range that indicates the position where those elements would be
   //!   if they there is no elements with key k.
   //! 
   //! <b>Complexity</b>: Logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   std::pair<const_iterator, const_iterator>
      equal_range(const_reference value) const
   {  return this->equal_range(value, priv_comp());   }

   //! <b>Effects</b>: Finds a range containing all elements whose key is k or
   //!   an empty range that indicates the position where those elements would be
   //!   if they there is no elements with key k.
   //! 
   //! <b>Complexity</b>: Logarithmic.
   //! 
   //! <b>Throws</b>: Nothing.
   template<class KeyType, class KeyValueCompare>
   std::pair<const_iterator, const_iterator>
      equal_range(const KeyType &key, KeyValueCompare comp) const
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      std::pair<node_ptr, node_ptr> ret
         (node_algorithms::equal_range(const_node_ptr(&priv_header()), key, key_node_comp));
      return std::pair<const_iterator, const_iterator>(const_iterator(ret.first, this), const_iterator(ret.second, this));
   }

   //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
   //!   Cloner should yield to nodes equivalent to the original nodes.
   //!
   //! <b>Effects</b>: Erases all the elements from *this
   //!   calling Disposer::operator()(pointer), clones all the 
   //!   elements from src calling Cloner::operator()(const_reference )
   //!   and inserts them on *this. Copies the predicate from the source container.
   //!
   //!   If cloner throws, all cloned elements are unlinked and disposed
   //!   calling Disposer::operator()(pointer).
   //!   
   //! <b>Complexity</b>: Linear to erased plus inserted elements.
   //! 
   //! <b>Throws</b>: If cloner throws or predicate copy assignment throws. Basic guarantee.
   template <class Cloner, class Disposer>
   void clone_from(const rbtree_impl &src, Cloner cloner, Disposer disposer)
   {
      this->clear_and_dispose(disposer);
      if(!src.empty()){
         detail::exception_disposer<rbtree_impl, Disposer>
            rollback(*this, disposer);
         node_algorithms::clone
            (const_node_ptr(&src.priv_header())
            ,node_ptr(&this->priv_header())
            ,detail::node_cloner<Cloner, rbtree_impl>(cloner, this)
            ,detail::node_disposer<Disposer, rbtree_impl>(disposer, this));
         this->priv_size_traits().set_size(src.priv_size_traits().get_size());
         this->priv_comp() = src.priv_comp();
         rollback.release();
      }
   }

   //! <b>Effects</b>: Unlinks the leftmost node from the tree.
   //! 
   //! <b>Complexity</b>: Average complexity is constant time.
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Notes</b>: This function breaks the tree and the tree can
   //!   only be used for more unlink_leftmost_without_rebalance calls.
   //!   This function is normally used to achieve a step by step
   //!   controlled destruction of the tree.
   pointer unlink_leftmost_without_rebalance()
   {
      node_ptr to_be_disposed(node_algorithms::unlink_leftmost_without_rebalance
                           (node_ptr(&priv_header())));
      if(!to_be_disposed)
         return 0;
      this->priv_size_traits().decrement();
      if(safemode_or_autounlink)//If this is commented does not work with normal_link
         node_algorithms::init(to_be_disposed);
      return get_real_value_traits().to_value_ptr(to_be_disposed);
   }

   //! <b>Requires</b>: replace_this must be a valid iterator of *this
   //!   and with_this must not be inserted in any tree.
   //! 
   //! <b>Effects</b>: Replaces replace_this in its position in the
   //!   tree with with_this. The tree does not need to be rebalanced.
   //! 
   //! <b>Complexity</b>: Constant. 
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: This function will break container ordering invariants if
   //!   with_this is not equivalent to *replace_this according to the
   //!   ordering rules. This function is faster than erasing and inserting
   //!   the node, since no rebalancing or comparison is needed.
   void replace_node(iterator replace_this, reference with_this)
   {
      node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this)
                                   , node_ptr(&priv_header())
                                   , get_real_value_traits().to_node_ptr(with_this));
      if(safemode_or_autounlink)
         node_algorithms::init(replace_this.pointed_node());
   }

   //! <b>Requires</b>: value must be an lvalue and shall be in a set of
   //!   appropriate type. Otherwise the behavior is undefined.
   //! 
   //! <b>Effects</b>: Returns: a valid iterator i belonging to the set
   //!   that points to the value
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: This static function is available only if the <i>value traits</i>
   //!   is stateless.
   static iterator s_iterator_to(reference value)
   {
      BOOST_STATIC_ASSERT((!stateful_value_traits));
      return iterator (value_traits::to_node_ptr(value), 0);
   }

   //! <b>Requires</b>: value must be an lvalue and shall be in a set of
   //!   appropriate type. Otherwise the behavior is undefined.
   //! 
   //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the
   //!   set that points to the value
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Note</b>: This static function is available only if the <i>value traits</i>
   //!   is stateless.
   static const_iterator s_iterator_to(const_reference value) 
   {
      BOOST_STATIC_ASSERT((!stateful_value_traits));
      return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), 0);
   }

   //! <b>Requires</b>: value must be an lvalue and shall be in a set of
   //!   appropriate type. Otherwise the behavior is undefined.
   //! 
   //! <b>Effects</b>: Returns: a valid iterator i belonging to the set
   //!   that points to the value
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   iterator iterator_to(reference value)
   {  return iterator (value_traits::to_node_ptr(value), this); }

   //! <b>Requires</b>: value must be an lvalue and shall be in a set of
   //!   appropriate type. Otherwise the behavior is undefined.
   //! 
   //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the
   //!   set that points to the value
   //! 
   //! <b>Complexity</b>: Constant.
   //! 
   //! <b>Throws</b>: Nothing.
   const_iterator iterator_to(const_reference value) const
   {  return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), this); }

   //! <b>Requires</b>: value shall not be in a tree.
   //! 
   //! <b>Effects</b>: init_node puts the hook of a value in a well-known default
   //!   state.
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Complexity</b>: Constant time.
   //! 
   //! <b>Note</b>: This function puts the hook in the well-known default state
   //!   used by auto_unlink and safe hooks.
   static void init_node(reference value)
   { node_algorithms::init(value_traits::to_node_ptr(value)); }

   //! <b>Effects</b>: removes ""value"" from the container.
   //! 
   //! <b>Throws</b>: Nothing.
   //! 
   //! <b>Complexity</b>: Logarithmic time.
   //! 
   //! <b>Note</b>: This static function is only usable with non-constant
   //! time size containers that have stateless comparison functors.
   //!
   //! If the user calls
   //! this function with a constant time size container or stateful comparison
   //! functor a compilation error will be issued.
   static void remove_node(reference value)
   {
      BOOST_STATIC_ASSERT((!constant_time_size));
      node_ptr to_remove(value_traits::to_node_ptr(value));
      node_algorithms::unlink(to_remove);
      if(safemode_or_autounlink)
         node_algorithms::init(to_remove);
   }

   /// @cond
   private:
   template<class Disposer>
   iterator private_erase(const_iterator b, const_iterator e, size_type &n, Disposer disposer)
   {
      for(n = 0; b != e; ++n)
        this->erase_and_dispose(b++, disposer);
      return b.unconst();
   }

   iterator private_erase(const_iterator b, const_iterator e, size_type &n)
   {
      for(n = 0; b != e; ++n)
        this->erase(b++);
      return b.unconst();
   }
   /// @endcond

   private:
   static rbtree_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
   {
      header_plus_size *r = detail::parent_from_member<header_plus_size, node>
         ( detail::boost_intrusive_get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
      node_plus_pred_t *n = detail::parent_from_member
         <node_plus_pred_t, header_plus_size>(r, &node_plus_pred_t::header_plus_size_);
      data_t *d = detail::parent_from_member<data_t, node_plus_pred_t>(n, &data_t::node_plus_pred_);
      rbtree_impl *rb  = detail::parent_from_member<rbtree_impl, data_t>(d, &rbtree_impl::data_);
      return *rb;
   }

   static rbtree_impl &priv_container_from_iterator(const const_iterator &it)
   {  return priv_container_from_end_iterator(it.end_iterator_from_it());   }
};

#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
template<class T, class ...Options>
#else
template<class Config>
#endif
inline bool operator<
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
(const rbtree_impl<T, Options...> &x, const rbtree_impl<T, Options...> &y)
#else
(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y)
#endif
{  return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());  }

#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
template<class T, class ...Options>
#else
template<class Config>
#endif
bool operator==
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
(const rbtree_impl<T, Options...> &x, const rbtree_impl<T, Options...> &y)
#else
(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y)
#endif
{
   typedef rbtree_impl<Config> tree_type;
   typedef typename tree_type::const_iterator const_iterator;

   if(tree_type::constant_time_size && x.size() != y.size()){
      return false;
   }
   const_iterator end1 = x.end();
   const_iterator i1 = x.begin();
   const_iterator i2 = y.begin();
   if(tree_type::constant_time_size){
      while (i1 != end1 && *i1 == *i2) {
         ++i1;
         ++i2;
      }
      return i1 == end1;
   }
   else{
      const_iterator end2 = y.end();
      while (i1 != end1 && i2 != end2 && *i1 == *i2) {
         ++i1;
         ++i2;
      }
      return i1 == end1 && i2 == end2;
   }
}

#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
template<class T, class ...Options>
#else
template<class Config>
#endif
inline bool operator!=
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
(const rbtree_impl<T, Options...> &x, const rbtree_impl<T, Options...> &y)
#else
(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y)
#endif
{  return !(x == y); }

#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
template<class T, class ...Options>
#else
template<class Config>
#endif
inline bool operator>
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
(const rbtree_impl<T, Options...> &x, const rbtree_impl<T, Options...> &y)
#else
(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y)
#endif
{  return y < x;  }

#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
template<class T, class ...Options>
#else
template<class Config>
#endif
inline bool operator<=
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
(const rbtree_impl<T, Options...> &x, const rbtree_impl<T, Options...> &y)
#else
(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y)
#endif
{  return !(y < x);  }

#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
template<class T, class ...Options>
#else
template<class Config>
#endif
inline bool operator>=
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
(const rbtree_impl<T, Options...> &x, const rbtree_impl<T, Options...> &y)
#else
(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y)
#endif
{  return !(x < y);  }

#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
template<class T, class ...Options>
#else
template<class Config>
#endif
inline void swap
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
(rbtree_impl<T, Options...> &x, rbtree_impl<T, Options...> &y)
#else
(rbtree_impl<Config> &x, rbtree_impl<Config> &y)
#endif
{  x.swap(y);  }

/// @cond
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template<class T, class O1 = none, class O2 = none
                , class O3 = none, class O4 = none
                >
#else
template<class T, class ...Options>
#endif
struct make_rbtree_opt
{
   typedef typename pack_options
      < set_defaults<T>, 
      #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
      O1, O2, O3, O4
      #else
      Options...
      #endif
      >::type packed_options;
   typedef typename detail::get_value_traits
      <T, typename packed_options::value_traits>::type value_traits;

   typedef setopt
         < value_traits
         , typename packed_options::compare
         , typename packed_options::size_type
         , packed_options::constant_time_size
         > type;
};
/// @endcond

//! Helper metafunction to define a \\c rbtree that yields to the same type when the
//! same options (either explicitly or implicitly) are used.
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template<class T, class ...Options>
#else
template<class T, class O1 = none, class O2 = none
                , class O3 = none, class O4 = none>
#endif
struct make_rbtree
{
   /// @cond
   typedef rbtree_impl
      < typename make_rbtree_opt<T, 
         #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
         O1, O2, O3, O4
         #else
         Options...
         #endif
         >::type
      > implementation_defined;
   /// @endcond
   typedef implementation_defined type;
};

#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED

#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template<class T, class O1, class O2, class O3, class O4>
#else
template<class T, class ...Options>
#endif
class rbtree
   :  public make_rbtree<T, 
      #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
      O1, O2, O3, O4
      #else
      Options...
      #endif
      >::type
{
   typedef typename make_rbtree
      <T, 
      #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
      O1, O2, O3, O4
      #else
      Options...
      #endif
      >::type   Base;
   BOOST_MOVABLE_BUT_NOT_COPYABLE(rbtree)

   public:
   typedef typename Base::value_compare      value_compare;
   typedef typename Base::value_traits       value_traits;
   typedef typename Base::real_value_traits  real_value_traits;
   typedef typename Base::iterator           iterator;
   typedef typename Base::const_iterator     const_iterator;

   //Assert if passed value traits are compatible with the type
   BOOST_STATIC_ASSERT((detail::is_same<typename real_value_traits::value_type, T>::value));

   rbtree( const value_compare &cmp = value_compare()
         , const value_traits &v_traits = value_traits())
      :  Base(cmp, v_traits)
   {}

   template<class Iterator>
   rbtree( bool unique, Iterator b, Iterator e
         , const value_compare &cmp = value_compare()
         , const value_traits &v_traits = value_traits())
      :  Base(unique, b, e, cmp, v_traits)
   {}

   rbtree(BOOST_RV_REF(rbtree) x)
      :  Base(::boost::move(static_cast<Base&>(x)))
   {}

   rbtree& operator=(BOOST_RV_REF(rbtree) x)
   {  this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this;  }

   static rbtree &container_from_end_iterator(iterator end_iterator)
   {  return static_cast<rbtree &>(Base::container_from_end_iterator(end_iterator));   }

   static const rbtree &container_from_end_iterator(const_iterator end_iterator)
   {  return static_cast<const rbtree &>(Base::container_from_end_iterator(end_iterator));   }

   static rbtree &container_from_it(iterator it)
   {  return static_cast<rbtree &>(Base::container_from_iterator(it));   }

   static const rbtree &container_from_it(const_iterator it)
   {  return static_cast<const rbtree &>(Base::container_from_iterator(it));   }
};

#endif


} //namespace intrusive 
} //namespace boost 

#include <boost/intrusive/detail/config_end.hpp>

#endif //BOOST_INTRUSIVE_RBTREE_HPP
",16153,True,3555.076126924655,median
"---
title: ""FreeBSD 10.1-RELEASE Announcement""
sidenav: download
---

:thisBranch: 10
:thisRelease: 10.1
:lastRelease: 10.0
:thisEOL: January 1, 2017

include::shared/en/urls.adoc[]
include::shared/releases.adoc[]
:thisDate: {rel101-current-date}

= FreeBSD {thisRelease}-RELEASE Announcement

Date: {thisDate}

The FreeBSD Release Engineering Team is pleased to announce the availability of FreeBSD {thisRelease}-RELEASE. This is the second release of the stable/{thisBranch} branch, which improves on the stability of FreeBSD {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/{thisRelease}R/relnotes/`
* `https://www.FreeBSD.org/releases/{thisRelease}R/errata/`

For more information about FreeBSD release engineering activities, please see:

* `https://www.FreeBSD.org/releng/`

== Availability

FreeBSD {thisRelease}-RELEASE is now available for the amd64, i386, ia64, powerpc, powerpc64, sparc64, and armv6 architectures.

FreeBSD {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/{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-{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-{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 {thisRelease}-RELEASE can also be purchased on CD-ROM or DVD from several vendors. One of the vendors that will be offering FreeBSD {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 {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 {thisRelease}-RELEASE may be downloaded via ftp from the following site:

* `ftp://ftp.freebsd.org/pub/FreeBSD/releases/ISO-IMAGES/{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 {thisRelease}-RELEASE virtual machine images may be downloaded via ftp from:

* `ftp://ftp.freebsd.org/pub/FreeBSD/releases/VM-IMAGES/{thisRelease}-RELEASE/`

For instructions on installing FreeBSD or updating an existing machine to {thisRelease}-RELEASE please see:

* `https://www.FreeBSD.org/releases/{thisRelease}R/installation/`

== Support

FreeBSD {thisRelease}-RELEASE will be supported until {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 {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 {thisRelease}-RELEASE includes:

[cols="","",]
|===
|Glen Barber <gjb@FreeBSD.org> |Release Engineering Lead, {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!
",12106,True,3619.308801601961,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).

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::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.


[[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 xref:integration/integration.adoc#jpaAndHibernatePersistingAScore[JPA/Hibernate],
xref:integration/integration.adoc#integrationWithXStream[XStream], xref:integration/integration.adoc#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.
* **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
    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 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.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,
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].
",12529,False,2218.7090018858285,median
"// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs --replace-value-regex ""__omp_offloading_[0-9a-z]+_[0-9a-z]+"" ""reduction_size[.].+[.]"" ""pl_cond[.].+[.|,]"" --prefix-filecheck-ir-name _
// Test target codegen - host bc file has to be created first.
// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=nvptx64-nvidia-cuda -emit-llvm-bc %s -o %t-ppc-host.bc
// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple nvptx64-unknown-unknown -fopenmp-targets=nvptx64-nvidia-cuda -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o - -disable-llvm-optzns | FileCheck %s --check-prefix=CHECK
// expected-no-diagnostics
#ifndef HEADER
#define HEADER

template<typename tx>
tx ftemplate(int n) {
  tx b[10];

  #pragma omp target
  {
    tx d = n;
    #pragma omp parallel for
    for(int i=0; i<10; i++) {
      b[i] += d;
    }
    b[3] += 1;
  }

  return b[3];
}

int bar(int n){
  int a = 0;

  a += ftemplate<int>(n);

  return a;
}

#endif
// CHECK1-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z9ftemplateIiET_i_l14_worker
// CHECK1-SAME: () #[[ATTR0:[0-9]+]] {
// CHECK1-NEXT:  entry:
// CHECK1-NEXT:    [[WORK_FN:%.*]] = alloca i8*, align 8
// CHECK1-NEXT:    [[EXEC_STATUS:%.*]] = alloca i8, align 1
// CHECK1-NEXT:    store i8* null, i8** [[WORK_FN]], align 8
// CHECK1-NEXT:    store i8 0, i8* [[EXEC_STATUS]], align 1
// CHECK1-NEXT:    br label [[DOTAWAIT_WORK:%.*]]
// CHECK1:       .await.work:
// CHECK1-NEXT:    call void @__kmpc_barrier_simple_spmd(%struct.ident_t* null, i32 0)
// CHECK1-NEXT:    [[TMP0:%.*]] = call i1 @__kmpc_kernel_parallel(i8** [[WORK_FN]])
// CHECK1-NEXT:    [[TMP1:%.*]] = zext i1 [[TMP0]] to i8
// CHECK1-NEXT:    store i8 [[TMP1]], i8* [[EXEC_STATUS]], align 1
// CHECK1-NEXT:    [[TMP2:%.*]] = load i8*, i8** [[WORK_FN]], align 8
// CHECK1-NEXT:    [[SHOULD_TERMINATE:%.*]] = icmp eq i8* [[TMP2]], null
// CHECK1-NEXT:    br i1 [[SHOULD_TERMINATE]], label [[DOTEXIT:%.*]], label [[DOTSELECT_WORKERS:%.*]]
// CHECK1:       .select.workers:
// CHECK1-NEXT:    [[TMP3:%.*]] = load i8, i8* [[EXEC_STATUS]], align 1
// CHECK1-NEXT:    [[IS_ACTIVE:%.*]] = icmp ne i8 [[TMP3]], 0
// CHECK1-NEXT:    br i1 [[IS_ACTIVE]], label [[DOTEXECUTE_PARALLEL:%.*]], label [[DOTBARRIER_PARALLEL:%.*]]
// CHECK1:       .execute.parallel:
// CHECK1-NEXT:    [[TMP4:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB2:[0-9]+]])
// CHECK1-NEXT:    [[TMP5:%.*]] = load i8*, i8** [[WORK_FN]], align 8
// CHECK1-NEXT:    [[WORK_MATCH:%.*]] = icmp eq i8* [[TMP5]], bitcast (void (i16, i32)* @__omp_outlined___wrapper to i8*)
// CHECK1-NEXT:    br i1 [[WORK_MATCH]], label [[DOTEXECUTE_FN:%.*]], label [[DOTCHECK_NEXT:%.*]]
// CHECK1:       .execute.fn:
// CHECK1-NEXT:    call void @__omp_outlined___wrapper(i16 0, i32 [[TMP4]]) #[[ATTR3:[0-9]+]]
// CHECK1-NEXT:    br label [[DOTTERMINATE_PARALLEL:%.*]]
// CHECK1:       .check.next:
// CHECK1-NEXT:    [[TMP6:%.*]] = bitcast i8* [[TMP2]] to void (i16, i32)*
// CHECK1-NEXT:    call void [[TMP6]](i16 0, i32 [[TMP4]])
// CHECK1-NEXT:    br label [[DOTTERMINATE_PARALLEL]]
// CHECK1:       .terminate.parallel:
// CHECK1-NEXT:    call void @__kmpc_kernel_end_parallel()
// CHECK1-NEXT:    br label [[DOTBARRIER_PARALLEL]]
// CHECK1:       .barrier.parallel:
// CHECK1-NEXT:    call void @__kmpc_barrier_simple_spmd(%struct.ident_t* null, i32 0)
// CHECK1-NEXT:    br label [[DOTAWAIT_WORK]]
// CHECK1:       .exit:
// CHECK1-NEXT:    ret void
// CHECK1-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z9ftemplateIiET_i_l14
// CHECK1-SAME: (i64 [[N:%.*]], [10 x i32]* nonnull align 4 dereferenceable(40) [[B:%.*]]) #[[ATTR1:[0-9]+]] {
// CHECK1-NEXT:  entry:
// CHECK1-NEXT:    [[N_ADDR:%.*]] = alloca i64, align 8
// CHECK1-NEXT:    [[B_ADDR:%.*]] = alloca [10 x i32]*, align 8
// CHECK1-NEXT:    [[CAPTURED_VARS_ADDRS:%.*]] = alloca [2 x i8*], align 8
// CHECK1-NEXT:    store i64 [[N]], i64* [[N_ADDR]], align 8
// CHECK1-NEXT:    store [10 x i32]* [[B]], [10 x i32]** [[B_ADDR]], align 8
// CHECK1-NEXT:    [[CONV:%.*]] = bitcast i64* [[N_ADDR]] to i32*
// CHECK1-NEXT:    [[TMP0:%.*]] = load [10 x i32]*, [10 x i32]** [[B_ADDR]], align 8
// CHECK1-NEXT:    [[NVPTX_TID:%.*]] = call i32 @llvm.nvvm.read.ptx.sreg.tid.x()
// CHECK1-NEXT:    [[NVPTX_NUM_THREADS:%.*]] = call i32 @llvm.nvvm.read.ptx.sreg.ntid.x()
// CHECK1-NEXT:    [[NVPTX_WARP_SIZE:%.*]] = call i32 @llvm.nvvm.read.ptx.sreg.warpsize()
// CHECK1-NEXT:    [[THREAD_LIMIT:%.*]] = sub nuw i32 [[NVPTX_NUM_THREADS]], [[NVPTX_WARP_SIZE]]
// CHECK1-NEXT:    [[TMP1:%.*]] = icmp ult i32 [[NVPTX_TID]], [[THREAD_LIMIT]]
// CHECK1-NEXT:    br i1 [[TMP1]], label [[DOTWORKER:%.*]], label [[DOTMASTERCHECK:%.*]]
// CHECK1:       .worker:
// CHECK1-NEXT:    call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z9ftemplateIiET_i_l14_worker() #[[ATTR3]]
// CHECK1-NEXT:    br label [[DOTEXIT:%.*]]
// CHECK1:       .mastercheck:
// CHECK1-NEXT:    [[NVPTX_TID1:%.*]] = call i32 @llvm.nvvm.read.ptx.sreg.tid.x()
// CHECK1-NEXT:    [[NVPTX_NUM_THREADS2:%.*]] = call i32 @llvm.nvvm.read.ptx.sreg.ntid.x()
// CHECK1-NEXT:    [[NVPTX_WARP_SIZE3:%.*]] = call i32 @llvm.nvvm.read.ptx.sreg.warpsize()
// CHECK1-NEXT:    [[TMP2:%.*]] = sub nuw i32 [[NVPTX_WARP_SIZE3]], 1
// CHECK1-NEXT:    [[TMP3:%.*]] = sub nuw i32 [[NVPTX_NUM_THREADS2]], 1
// CHECK1-NEXT:    [[TMP4:%.*]] = xor i32 [[TMP2]], -1
// CHECK1-NEXT:    [[MASTER_TID:%.*]] = and i32 [[TMP3]], [[TMP4]]
// CHECK1-NEXT:    [[TMP5:%.*]] = icmp eq i32 [[NVPTX_TID1]], [[MASTER_TID]]
// CHECK1-NEXT:    br i1 [[TMP5]], label [[DOTMASTER:%.*]], label [[DOTEXIT]]
// CHECK1:       .master:
// CHECK1-NEXT:    [[NVPTX_NUM_THREADS4:%.*]] = call i32 @llvm.nvvm.read.ptx.sreg.ntid.x()
// CHECK1-NEXT:    [[NVPTX_WARP_SIZE5:%.*]] = call i32 @llvm.nvvm.read.ptx.sreg.warpsize()
// CHECK1-NEXT:    [[THREAD_LIMIT6:%.*]] = sub nuw i32 [[NVPTX_NUM_THREADS4]], [[NVPTX_WARP_SIZE5]]
// CHECK1-NEXT:    call void @__kmpc_kernel_init(i32 [[THREAD_LIMIT6]], i16 1)
// CHECK1-NEXT:    call void @__kmpc_data_sharing_init_stack()
// CHECK1-NEXT:    [[TMP6:%.*]] = load i16, i16* @""_openmp_static_kernel$is_shared"", align 2
// CHECK1-NEXT:    [[TMP7:%.*]] = load i64, i64* @""_openmp_static_kernel$size"", align 8
// CHECK1-NEXT:    call void @__kmpc_get_team_static_memory(i16 0, i8* addrspacecast (i8 addrspace(3)* getelementptr inbounds (%""union._shared_openmp_static_memory_type_$_"", %""union._shared_openmp_static_memory_type_$_"" addrspace(3)* @""_openmp_shared_static_glob_rd_$_"", i32 0, i32 0, i32 0) to i8*), i64 [[TMP7]], i16 [[TMP6]], i8** addrspacecast (i8* addrspace(3)* @""_openmp_kernel_static_glob_rd$ptr"" to i8**))
// CHECK1-NEXT:    [[TMP8:%.*]] = load i8*, i8* addrspace(3)* @""_openmp_kernel_static_glob_rd$ptr"", align 8
// CHECK1-NEXT:    [[TMP9:%.*]] = getelementptr inbounds i8, i8* [[TMP8]], i64 0
// CHECK1-NEXT:    [[TMP10:%.*]] = bitcast i8* [[TMP9]] to %struct._globalized_locals_ty*
// CHECK1-NEXT:    [[D:%.*]] = getelementptr inbounds [[STRUCT__GLOBALIZED_LOCALS_TY:%.*]], %struct._globalized_locals_ty* [[TMP10]], i32 0, i32 0
// CHECK1-NEXT:    [[TMP11:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB2]])
// CHECK1-NEXT:    [[TMP12:%.*]] = load i32, i32* [[CONV]], align 8
// CHECK1-NEXT:    store i32 [[TMP12]], i32* [[D]], align 4
// CHECK1-NEXT:    [[TMP13:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[CAPTURED_VARS_ADDRS]], i64 0, i64 0
// CHECK1-NEXT:    [[TMP14:%.*]] = bitcast [10 x i32]* [[TMP0]] to i8*
// CHECK1-NEXT:    store i8* [[TMP14]], i8** [[TMP13]], align 8
// CHECK1-NEXT:    [[TMP15:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[CAPTURED_VARS_ADDRS]], i64 0, i64 1
// CHECK1-NEXT:    [[TMP16:%.*]] = bitcast i32* [[D]] to i8*
// CHECK1-NEXT:    store i8* [[TMP16]], i8** [[TMP15]], align 8
// CHECK1-NEXT:    [[TMP17:%.*]] = bitcast [2 x i8*]* [[CAPTURED_VARS_ADDRS]] to i8**
// CHECK1-NEXT:    call void @__kmpc_parallel_51(%struct.ident_t* @[[GLOB2]], i32 [[TMP11]], i32 1, i32 -1, i32 -1, i8* bitcast (void (i32*, i32*, [10 x i32]*, i32*)* @__omp_outlined__ to i8*), i8* bitcast (void (i16, i32)* @__omp_outlined___wrapper to i8*), i8** [[TMP17]], i64 2)
// CHECK1-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [10 x i32], [10 x i32]* [[TMP0]], i64 0, i64 3
// CHECK1-NEXT:    [[TMP18:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
// CHECK1-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP18]], 1
// CHECK1-NEXT:    store i32 [[ADD]], i32* [[ARRAYIDX]], align 4
// CHECK1-NEXT:    [[TMP19:%.*]] = load i16, i16* @""_openmp_static_kernel$is_shared"", align 2
// CHECK1-NEXT:    call void @__kmpc_restore_team_static_memory(i16 0, i16 [[TMP19]])
// CHECK1-NEXT:    br label [[DOTTERMINATION_NOTIFIER:%.*]]
// CHECK1:       .termination.notifier:
// CHECK1-NEXT:    call void @__kmpc_kernel_deinit(i16 1)
// CHECK1-NEXT:    call void @__kmpc_barrier_simple_spmd(%struct.ident_t* null, i32 0)
// CHECK1-NEXT:    br label [[DOTEXIT]]
// CHECK1:       .exit:
// CHECK1-NEXT:    ret void
// CHECK1-LABEL: define {{[^@]+}}@__omp_outlined__
// CHECK1-SAME: (i32* noalias [[DOTGLOBAL_TID_:%.*]], i32* noalias [[DOTBOUND_TID_:%.*]], [10 x i32]* nonnull align 4 dereferenceable(40) [[B:%.*]], i32* nonnull align 4 dereferenceable(4) [[D:%.*]]) #[[ATTR1]] {
// CHECK1-NEXT:  entry:
// CHECK1-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca i32*, align 8
// CHECK1-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca i32*, align 8
// CHECK1-NEXT:    [[B_ADDR:%.*]] = alloca [10 x i32]*, align 8
// CHECK1-NEXT:    [[D_ADDR:%.*]] = alloca i32*, align 8
// CHECK1-NEXT:    [[DOTOMP_IV:%.*]] = alloca i32, align 4
// CHECK1-NEXT:    [[TMP:%.*]] = alloca i32, align 4
// CHECK1-NEXT:    [[DOTOMP_LB:%.*]] = alloca i32, align 4
// CHECK1-NEXT:    [[DOTOMP_UB:%.*]] = alloca i32, align 4
// CHECK1-NEXT:    [[DOTOMP_STRIDE:%.*]] = alloca i32, align 4
// CHECK1-NEXT:    [[DOTOMP_IS_LAST:%.*]] = alloca i32, align 4
// CHECK1-NEXT:    [[I:%.*]] = alloca i32, align 4
// CHECK1-NEXT:    store i32* [[DOTGLOBAL_TID_]], i32** [[DOTGLOBAL_TID__ADDR]], align 8
// CHECK1-NEXT:    store i32* [[DOTBOUND_TID_]], i32** [[DOTBOUND_TID__ADDR]], align 8
// CHECK1-NEXT:    store [10 x i32]* [[B]], [10 x i32]** [[B_ADDR]], align 8
// CHECK1-NEXT:    store i32* [[D]], i32** [[D_ADDR]], align 8
// CHECK1-NEXT:    [[TMP0:%.*]] = load [10 x i32]*, [10 x i32]** [[B_ADDR]], align 8
// CHECK1-NEXT:    [[TMP1:%.*]] = load i32*, i32** [[D_ADDR]], align 8
// CHECK1-NEXT:    store i32 0, i32* [[DOTOMP_LB]], align 4
// CHECK1-NEXT:    store i32 9, i32* [[DOTOMP_UB]], align 4
// CHECK1-NEXT:    store i32 1, i32* [[DOTOMP_STRIDE]], align 4
// CHECK1-NEXT:    store i32 0, i32* [[DOTOMP_IS_LAST]], align 4
// CHECK1-NEXT:    [[TMP2:%.*]] = load i32*, i32** [[DOTGLOBAL_TID__ADDR]], align 8
// CHECK1-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
// CHECK1-NEXT:    call void @__kmpc_for_static_init_4(%struct.ident_t* @[[GLOB1:[0-9]+]], i32 [[TMP3]], i32 33, i32* [[DOTOMP_IS_LAST]], i32* [[DOTOMP_LB]], i32* [[DOTOMP_UB]], i32* [[DOTOMP_STRIDE]], i32 1, i32 1)
// CHECK1-NEXT:    br label [[OMP_DISPATCH_COND:%.*]]
// CHECK1:       omp.dispatch.cond:
// CHECK1-NEXT:    [[TMP4:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
// CHECK1-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[TMP4]], 9
// CHECK1-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
// CHECK1:       cond.true:
// CHECK1-NEXT:    br label [[COND_END:%.*]]
// CHECK1:       cond.false:
// CHECK1-NEXT:    [[TMP5:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
// CHECK1-NEXT:    br label [[COND_END]]
// CHECK1:       cond.end:
// CHECK1-NEXT:    [[COND:%.*]] = phi i32 [ 9, [[COND_TRUE]] ], [ [[TMP5]], [[COND_FALSE]] ]
// CHECK1-NEXT:    store i32 [[COND]], i32* [[DOTOMP_UB]], align 4
// CHECK1-NEXT:    [[TMP6:%.*]] = load i32, i32* [[DOTOMP_LB]], align 4
// CHECK1-NEXT:    store i32 [[TMP6]], i32* [[DOTOMP_IV]], align 4
// CHECK1-NEXT:    [[TMP7:%.*]] = load i32, i32* [[DOTOMP_IV]], align 4
// CHECK1-NEXT:    [[TMP8:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
// CHECK1-NEXT:    [[CMP1:%.*]] = icmp sle i32 [[TMP7]], [[TMP8]]
// CHECK1-NEXT:    br i1 [[CMP1]], label [[OMP_DISPATCH_BODY:%.*]], label [[OMP_DISPATCH_END:%.*]]
// CHECK1:       omp.dispatch.body:
// CHECK1-NEXT:    br label [[OMP_INNER_FOR_COND:%.*]]
// CHECK1:       omp.inner.for.cond:
// CHECK1-NEXT:    [[TMP9:%.*]] = load i32, i32* [[DOTOMP_IV]], align 4
// CHECK1-NEXT:    [[TMP10:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
// CHECK1-NEXT:    [[CMP2:%.*]] = icmp sle i32 [[TMP9]], [[TMP10]]
// CHECK1-NEXT:    br i1 [[CMP2]], label [[OMP_INNER_FOR_BODY:%.*]], label [[OMP_INNER_FOR_END:%.*]]
// CHECK1:       omp.inner.for.body:
// CHECK1-NEXT:    [[TMP11:%.*]] = load i32, i32* [[DOTOMP_IV]], align 4
// CHECK1-NEXT:    [[MUL:%.*]] = mul nsw i32 [[TMP11]], 1
// CHECK1-NEXT:    [[ADD:%.*]] = add nsw i32 0, [[MUL]]
// CHECK1-NEXT:    store i32 [[ADD]], i32* [[I]], align 4
// CHECK1-NEXT:    [[TMP12:%.*]] = load i32, i32* [[TMP1]], align 4
// CHECK1-NEXT:    [[TMP13:%.*]] = load i32, i32* [[I]], align 4
// CHECK1-NEXT:    [[IDXPROM:%.*]] = sext i32 [[TMP13]] to i64
// CHECK1-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [10 x i32], [10 x i32]* [[TMP0]], i64 0, i64 [[IDXPROM]]
// CHECK1-NEXT:    [[TMP14:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
// CHECK1-NEXT:    [[ADD3:%.*]] = add nsw i32 [[TMP14]], [[TMP12]]
// CHECK1-NEXT:    store i32 [[ADD3]], i32* [[ARRAYIDX]], align 4
// CHECK1-NEXT:    br label [[OMP_BODY_CONTINUE:%.*]]
// CHECK1:       omp.body.continue:
// CHECK1-NEXT:    br label [[OMP_INNER_FOR_INC:%.*]]
// CHECK1:       omp.inner.for.inc:
// CHECK1-NEXT:    [[TMP15:%.*]] = load i32, i32* [[DOTOMP_IV]], align 4
// CHECK1-NEXT:    [[ADD4:%.*]] = add nsw i32 [[TMP15]], 1
// CHECK1-NEXT:    store i32 [[ADD4]], i32* [[DOTOMP_IV]], align 4
// CHECK1-NEXT:    br label [[OMP_INNER_FOR_COND]]
// CHECK1:       omp.inner.for.end:
// CHECK1-NEXT:    br label [[OMP_DISPATCH_INC:%.*]]
// CHECK1:       omp.dispatch.inc:
// CHECK1-NEXT:    [[TMP16:%.*]] = load i32, i32* [[DOTOMP_LB]], align 4
// CHECK1-NEXT:    [[TMP17:%.*]] = load i32, i32* [[DOTOMP_STRIDE]], align 4
// CHECK1-NEXT:    [[ADD5:%.*]] = add nsw i32 [[TMP16]], [[TMP17]]
// CHECK1-NEXT:    store i32 [[ADD5]], i32* [[DOTOMP_LB]], align 4
// CHECK1-NEXT:    [[TMP18:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
// CHECK1-NEXT:    [[TMP19:%.*]] = load i32, i32* [[DOTOMP_STRIDE]], align 4
// CHECK1-NEXT:    [[ADD6:%.*]] = add nsw i32 [[TMP18]], [[TMP19]]
// CHECK1-NEXT:    store i32 [[ADD6]], i32* [[DOTOMP_UB]], align 4
// CHECK1-NEXT:    br label [[OMP_DISPATCH_COND]]
// CHECK1:       omp.dispatch.end:
// CHECK1-NEXT:    call void @__kmpc_for_static_fini(%struct.ident_t* @[[GLOB1]], i32 [[TMP3]])
// CHECK1-NEXT:    ret void
// CHECK1-LABEL: define {{[^@]+}}@__omp_outlined___wrapper
// CHECK1-SAME: (i16 zeroext [[TMP0:%.*]], i32 [[TMP1:%.*]]) #[[ATTR0]] {
// CHECK1-NEXT:  entry:
// CHECK1-NEXT:    [[DOTADDR:%.*]] = alloca i16, align 2
// CHECK1-NEXT:    [[DOTADDR1:%.*]] = alloca i32, align 4
// CHECK1-NEXT:    [[DOTZERO_ADDR:%.*]] = alloca i32, align 4
// CHECK1-NEXT:    [[GLOBAL_ARGS:%.*]] = alloca i8**, align 8
// CHECK1-NEXT:    store i32 0, i32* [[DOTZERO_ADDR]], align 4
// CHECK1-NEXT:    store i16 [[TMP0]], i16* [[DOTADDR]], align 2
// CHECK1-NEXT:    store i32 [[TMP1]], i32* [[DOTADDR1]], align 4
// CHECK1-NEXT:    call void @__kmpc_get_shared_variables(i8*** [[GLOBAL_ARGS]])
// CHECK1-NEXT:    [[TMP2:%.*]] = load i8**, i8*** [[GLOBAL_ARGS]], align 8
// CHECK1-NEXT:    [[TMP3:%.*]] = getelementptr inbounds i8*, i8** [[TMP2]], i64 0
// CHECK1-NEXT:    [[TMP4:%.*]] = bitcast i8** [[TMP3]] to [10 x i32]**
// CHECK1-NEXT:    [[TMP5:%.*]] = load [10 x i32]*, [10 x i32]** [[TMP4]], align 8
// CHECK1-NEXT:    [[TMP6:%.*]] = getelementptr inbounds i8*, i8** [[TMP2]], i64 1
// CHECK1-NEXT:    [[TMP7:%.*]] = bitcast i8** [[TMP6]] to i32**
// CHECK1-NEXT:    [[TMP8:%.*]] = load i32*, i32** [[TMP7]], align 8
// CHECK1-NEXT:    call void @__omp_outlined__(i32* [[DOTADDR1]], i32* [[DOTZERO_ADDR]], [10 x i32]* [[TMP5]], i32* [[TMP8]]) #[[ATTR3]]
// CHECK1-NEXT:    ret void
// CHECK2-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z9ftemplateIiET_i_l14_worker
// CHECK2-SAME: () #[[ATTR0:[0-9]+]] {
// CHECK2-NEXT:  entry:
// CHECK2-NEXT:    [[WORK_FN:%.*]] = alloca i8*, align 8
// CHECK2-NEXT:    [[EXEC_STATUS:%.*]] = alloca i8, align 1
// CHECK2-NEXT:    store i8* null, i8** [[WORK_FN]], align 8
// CHECK2-NEXT:    store i8 0, i8* [[EXEC_STATUS]], align 1
// CHECK2-NEXT:    br label [[DOTAWAIT_WORK:%.*]]
// CHECK2:       .await.work:
// CHECK2-NEXT:    call void @__kmpc_barrier_simple_spmd(%struct.ident_t* null, i32 0)
// CHECK2-NEXT:    [[TMP0:%.*]] = call i1 @__kmpc_kernel_parallel(i8** [[WORK_FN]])
// CHECK2-NEXT:    [[TMP1:%.*]] = zext i1 [[TMP0]] to i8
// CHECK2-NEXT:    store i8 [[TMP1]], i8* [[EXEC_STATUS]], align 1
// CHECK2-NEXT:    [[TMP2:%.*]] = load i8*, i8** [[WORK_FN]], align 8
// CHECK2-NEXT:    [[SHOULD_TERMINATE:%.*]] = icmp eq i8* [[TMP2]], null
// CHECK2-NEXT:    br i1 [[SHOULD_TERMINATE]], label [[DOTEXIT:%.*]], label [[DOTSELECT_WORKERS:%.*]]
// CHECK2:       .select.workers:
// CHECK2-NEXT:    [[TMP3:%.*]] = load i8, i8* [[EXEC_STATUS]], align 1
// CHECK2-NEXT:    [[IS_ACTIVE:%.*]] = icmp ne i8 [[TMP3]], 0
// CHECK2-NEXT:    br i1 [[IS_ACTIVE]], label [[DOTEXECUTE_PARALLEL:%.*]], label [[DOTBARRIER_PARALLEL:%.*]]
// CHECK2:       .execute.parallel:
// CHECK2-NEXT:    [[TMP4:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB2:[0-9]+]])
// CHECK2-NEXT:    [[TMP5:%.*]] = load i8*, i8** [[WORK_FN]], align 8
// CHECK2-NEXT:    [[WORK_MATCH:%.*]] = icmp eq i8* [[TMP5]], bitcast (void (i16, i32)* @__omp_outlined___wrapper to i8*)
// CHECK2-NEXT:    br i1 [[WORK_MATCH]], label [[DOTEXECUTE_FN:%.*]], label [[DOTCHECK_NEXT:%.*]]
// CHECK2:       .execute.fn:
// CHECK2-NEXT:    call void @__omp_outlined___wrapper(i16 0, i32 [[TMP4]]) #[[ATTR3:[0-9]+]]
// CHECK2-NEXT:    br label [[DOTTERMINATE_PARALLEL:%.*]]
// CHECK2:       .check.next:
// CHECK2-NEXT:    [[TMP6:%.*]] = bitcast i8* [[TMP2]] to void (i16, i32)*
// CHECK2-NEXT:    call void [[TMP6]](i16 0, i32 [[TMP4]])
// CHECK2-NEXT:    br label [[DOTTERMINATE_PARALLEL]]
// CHECK2:       .terminate.parallel:
// CHECK2-NEXT:    call void @__kmpc_kernel_end_parallel()
// CHECK2-NEXT:    br label [[DOTBARRIER_PARALLEL]]
// CHECK2:       .barrier.parallel:
// CHECK2-NEXT:    call void @__kmpc_barrier_simple_spmd(%struct.ident_t* null, i32 0)
// CHECK2-NEXT:    br label [[DOTAWAIT_WORK]]
// CHECK2:       .exit:
// CHECK2-NEXT:    ret void
// CHECK2-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z9ftemplateIiET_i_l14
// CHECK2-SAME: (i64 [[N:%.*]], [10 x i32]* nonnull align 4 dereferenceable(40) [[B:%.*]]) #[[ATTR1:[0-9]+]] {
// CHECK2-NEXT:  entry:
// CHECK2-NEXT:    [[N_ADDR:%.*]] = alloca i64, align 8
// CHECK2-NEXT:    [[B_ADDR:%.*]] = alloca [10 x i32]*, align 8
// CHECK2-NEXT:    [[CAPTURED_VARS_ADDRS:%.*]] = alloca [2 x i8*], align 8
// CHECK2-NEXT:    store i64 [[N]], i64* [[N_ADDR]], align 8
// CHECK2-NEXT:    store [10 x i32]* [[B]], [10 x i32]** [[B_ADDR]], align 8
// CHECK2-NEXT:    [[CONV:%.*]] = bitcast i64* [[N_ADDR]] to i32*
// CHECK2-NEXT:    [[TMP0:%.*]] = load [10 x i32]*, [10 x i32]** [[B_ADDR]], align 8
// CHECK2-NEXT:    [[NVPTX_TID:%.*]] = call i32 @llvm.nvvm.read.ptx.sreg.tid.x()
// CHECK2-NEXT:    [[NVPTX_NUM_THREADS:%.*]] = call i32 @llvm.nvvm.read.ptx.sreg.ntid.x()
// CHECK2-NEXT:    [[NVPTX_WARP_SIZE:%.*]] = call i32 @llvm.nvvm.read.ptx.sreg.warpsize()
// CHECK2-NEXT:    [[THREAD_LIMIT:%.*]] = sub nuw i32 [[NVPTX_NUM_THREADS]], [[NVPTX_WARP_SIZE]]
// CHECK2-NEXT:    [[TMP1:%.*]] = icmp ult i32 [[NVPTX_TID]], [[THREAD_LIMIT]]
// CHECK2-NEXT:    br i1 [[TMP1]], label [[DOTWORKER:%.*]], label [[DOTMASTERCHECK:%.*]]
// CHECK2:       .worker:
// CHECK2-NEXT:    call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z9ftemplateIiET_i_l14_worker() #[[ATTR3]]
// CHECK2-NEXT:    br label [[DOTEXIT:%.*]]
// CHECK2:       .mastercheck:
// CHECK2-NEXT:    [[NVPTX_TID1:%.*]] = call i32 @llvm.nvvm.read.ptx.sreg.tid.x()
// CHECK2-NEXT:    [[NVPTX_NUM_THREADS2:%.*]] = call i32 @llvm.nvvm.read.ptx.sreg.ntid.x()
// CHECK2-NEXT:    [[NVPTX_WARP_SIZE3:%.*]] = call i32 @llvm.nvvm.read.ptx.sreg.warpsize()
// CHECK2-NEXT:    [[TMP2:%.*]] = sub nuw i32 [[NVPTX_WARP_SIZE3]], 1
// CHECK2-NEXT:    [[TMP3:%.*]] = sub nuw i32 [[NVPTX_NUM_THREADS2]], 1
// CHECK2-NEXT:    [[TMP4:%.*]] = xor i32 [[TMP2]], -1
// CHECK2-NEXT:    [[MASTER_TID:%.*]] = and i32 [[TMP3]], [[TMP4]]
// CHECK2-NEXT:    [[TMP5:%.*]] = icmp eq i32 [[NVPTX_TID1]], [[MASTER_TID]]
// CHECK2-NEXT:    br i1 [[TMP5]], label [[DOTMASTER:%.*]], label [[DOTEXIT]]
// CHECK2:       .master:
// CHECK2-NEXT:    [[NVPTX_NUM_THREADS4:%.*]] = call i32 @llvm.nvvm.read.ptx.sreg.ntid.x()
// CHECK2-NEXT:    [[NVPTX_WARP_SIZE5:%.*]] = call i32 @llvm.nvvm.read.ptx.sreg.warpsize()
// CHECK2-NEXT:    [[THREAD_LIMIT6:%.*]] = sub nuw i32 [[NVPTX_NUM_THREADS4]], [[NVPTX_WARP_SIZE5]]
// CHECK2-NEXT:    call void @__kmpc_kernel_init(i32 [[THREAD_LIMIT6]], i16 1)
// CHECK2-NEXT:    call void @__kmpc_data_sharing_init_stack()
// CHECK2-NEXT:    [[TMP6:%.*]] = call i8* @__kmpc_data_sharing_push_stack(i64 4, i16 1)
// CHECK2-NEXT:    [[TMP7:%.*]] = bitcast i8* [[TMP6]] to %struct._globalized_locals_ty*
// CHECK2-NEXT:    [[D:%.*]] = getelementptr inbounds [[STRUCT__GLOBALIZED_LOCALS_TY:%.*]], %struct._globalized_locals_ty* [[TMP7]], i32 0, i32 0
// CHECK2-NEXT:    [[TMP8:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB2]])
// CHECK2-NEXT:    [[TMP9:%.*]] = load i32, i32* [[CONV]], align 8
// CHECK2-NEXT:    store i32 [[TMP9]], i32* [[D]], align 4
// CHECK2-NEXT:    [[TMP10:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[CAPTURED_VARS_ADDRS]], i64 0, i64 0
// CHECK2-NEXT:    [[TMP11:%.*]] = bitcast [10 x i32]* [[TMP0]] to i8*
// CHECK2-NEXT:    store i8* [[TMP11]], i8** [[TMP10]], align 8
// CHECK2-NEXT:    [[TMP12:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[CAPTURED_VARS_ADDRS]], i64 0, i64 1
// CHECK2-NEXT:    [[TMP13:%.*]] = bitcast i32* [[D]] to i8*
// CHECK2-NEXT:    store i8* [[TMP13]], i8** [[TMP12]], align 8
// CHECK2-NEXT:    [[TMP14:%.*]] = bitcast [2 x i8*]* [[CAPTURED_VARS_ADDRS]] to i8**
// CHECK2-NEXT:    call void @__kmpc_parallel_51(%struct.ident_t* @[[GLOB2]], i32 [[TMP8]], i32 1, i32 -1, i32 -1, i8* bitcast (void (i32*, i32*, [10 x i32]*, i32*)* @__omp_outlined__ to i8*), i8* bitcast (void (i16, i32)* @__omp_outlined___wrapper to i8*), i8** [[TMP14]], i64 2)
// CHECK2-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [10 x i32], [10 x i32]* [[TMP0]], i64 0, i64 3
// CHECK2-NEXT:    [[TMP15:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
// CHECK2-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP15]], 1
// CHECK2-NEXT:    store i32 [[ADD]], i32* [[ARRAYIDX]], align 4
// CHECK2-NEXT:    call void @__kmpc_data_sharing_pop_stack(i8* [[TMP6]])
// CHECK2-NEXT:    br label [[DOTTERMINATION_NOTIFIER:%.*]]
// CHECK2:       .termination.notifier:
// CHECK2-NEXT:    call void @__kmpc_kernel_deinit(i16 1)
// CHECK2-NEXT:    call void @__kmpc_barrier_simple_spmd(%struct.ident_t* null, i32 0)
// CHECK2-NEXT:    br label [[DOTEXIT]]
// CHECK2:       .exit:
// CHECK2-NEXT:    ret void
// CHECK2-LABEL: define {{[^@]+}}@__omp_outlined__
// CHECK2-SAME: (i32* noalias [[DOTGLOBAL_TID_:%.*]], i32* noalias [[DOTBOUND_TID_:%.*]], [10 x i32]* nonnull align 4 dereferenceable(40) [[B:%.*]], i32* nonnull align 4 dereferenceable(4) [[D:%.*]]) #[[ATTR1]] {
// CHECK2-NEXT:  entry:
// CHECK2-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca i32*, align 8
// CHECK2-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca i32*, align 8
// CHECK2-NEXT:    [[B_ADDR:%.*]] = alloca [10 x i32]*, align 8
// CHECK2-NEXT:    [[D_ADDR:%.*]] = alloca i32*, align 8
// CHECK2-NEXT:    [[DOTOMP_IV:%.*]] = alloca i32, align 4
// CHECK2-NEXT:    [[TMP:%.*]] = alloca i32, align 4
// CHECK2-NEXT:    [[DOTOMP_LB:%.*]] = alloca i32, align 4
// CHECK2-NEXT:    [[DOTOMP_UB:%.*]] = alloca i32, align 4
// CHECK2-NEXT:    [[DOTOMP_STRIDE:%.*]] = alloca i32, align 4
// CHECK2-NEXT:    [[DOTOMP_IS_LAST:%.*]] = alloca i32, align 4
// CHECK2-NEXT:    [[I:%.*]] = alloca i32, align 4
// CHECK2-NEXT:    store i32* [[DOTGLOBAL_TID_]], i32** [[DOTGLOBAL_TID__ADDR]], align 8
// CHECK2-NEXT:    store i32* [[DOTBOUND_TID_]], i32** [[DOTBOUND_TID__ADDR]], align 8
// CHECK2-NEXT:    store [10 x i32]* [[B]], [10 x i32]** [[B_ADDR]], align 8
// CHECK2-NEXT:    store i32* [[D]], i32** [[D_ADDR]], align 8
// CHECK2-NEXT:    [[TMP0:%.*]] = load [10 x i32]*, [10 x i32]** [[B_ADDR]], align 8
// CHECK2-NEXT:    [[TMP1:%.*]] = load i32*, i32** [[D_ADDR]], align 8
// CHECK2-NEXT:    store i32 0, i32* [[DOTOMP_LB]], align 4
// CHECK2-NEXT:    store i32 9, i32* [[DOTOMP_UB]], align 4
// CHECK2-NEXT:    store i32 1, i32* [[DOTOMP_STRIDE]], align 4
// CHECK2-NEXT:    store i32 0, i32* [[DOTOMP_IS_LAST]], align 4
// CHECK2-NEXT:    [[TMP2:%.*]] = load i32*, i32** [[DOTGLOBAL_TID__ADDR]], align 8
// CHECK2-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
// CHECK2-NEXT:    call void @__kmpc_for_static_init_4(%struct.ident_t* @[[GLOB1:[0-9]+]], i32 [[TMP3]], i32 33, i32* [[DOTOMP_IS_LAST]], i32* [[DOTOMP_LB]], i32* [[DOTOMP_UB]], i32* [[DOTOMP_STRIDE]], i32 1, i32 1)
// CHECK2-NEXT:    br label [[OMP_DISPATCH_COND:%.*]]
// CHECK2:       omp.dispatch.cond:
// CHECK2-NEXT:    [[TMP4:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
// CHECK2-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[TMP4]], 9
// CHECK2-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
// CHECK2:       cond.true:
// CHECK2-NEXT:    br label [[COND_END:%.*]]
// CHECK2:       cond.false:
// CHECK2-NEXT:    [[TMP5:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
// CHECK2-NEXT:    br label [[COND_END]]
// CHECK2:       cond.end:
// CHECK2-NEXT:    [[COND:%.*]] = phi i32 [ 9, [[COND_TRUE]] ], [ [[TMP5]], [[COND_FALSE]] ]
// CHECK2-NEXT:    store i32 [[COND]], i32* [[DOTOMP_UB]], align 4
// CHECK2-NEXT:    [[TMP6:%.*]] = load i32, i32* [[DOTOMP_LB]], align 4
// CHECK2-NEXT:    store i32 [[TMP6]], i32* [[DOTOMP_IV]], align 4
// CHECK2-NEXT:    [[TMP7:%.*]] = load i32, i32* [[DOTOMP_IV]], align 4
// CHECK2-NEXT:    [[TMP8:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
// CHECK2-NEXT:    [[CMP1:%.*]] = icmp sle i32 [[TMP7]], [[TMP8]]
// CHECK2-NEXT:    br i1 [[CMP1]], label [[OMP_DISPATCH_BODY:%.*]], label [[OMP_DISPATCH_END:%.*]]
// CHECK2:       omp.dispatch.body:
// CHECK2-NEXT:    br label [[OMP_INNER_FOR_COND:%.*]]
// CHECK2:       omp.inner.for.cond:
// CHECK2-NEXT:    [[TMP9:%.*]] = load i32, i32* [[DOTOMP_IV]], align 4
// CHECK2-NEXT:    [[TMP10:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
// CHECK2-NEXT:    [[CMP2:%.*]] = icmp sle i32 [[TMP9]], [[TMP10]]
// CHECK2-NEXT:    br i1 [[CMP2]], label [[OMP_INNER_FOR_BODY:%.*]], label [[OMP_INNER_FOR_END:%.*]]
// CHECK2:       omp.inner.for.body:
// CHECK2-NEXT:    [[TMP11:%.*]] = load i32, i32* [[DOTOMP_IV]], align 4
// CHECK2-NEXT:    [[MUL:%.*]] = mul nsw i32 [[TMP11]], 1
// CHECK2-NEXT:    [[ADD:%.*]] = add nsw i32 0, [[MUL]]
// CHECK2-NEXT:    store i32 [[ADD]], i32* [[I]], align 4
// CHECK2-NEXT:    [[TMP12:%.*]] = load i32, i32* [[TMP1]], align 4
// CHECK2-NEXT:    [[TMP13:%.*]] = load i32, i32* [[I]], align 4
// CHECK2-NEXT:    [[IDXPROM:%.*]] = sext i32 [[TMP13]] to i64
// CHECK2-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [10 x i32], [10 x i32]* [[TMP0]], i64 0, i64 [[IDXPROM]]
// CHECK2-NEXT:    [[TMP14:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
// CHECK2-NEXT:    [[ADD3:%.*]] = add nsw i32 [[TMP14]], [[TMP12]]
// CHECK2-NEXT:    store i32 [[ADD3]], i32* [[ARRAYIDX]], align 4
// CHECK2-NEXT:    br label [[OMP_BODY_CONTINUE:%.*]]
// CHECK2:       omp.body.continue:
// CHECK2-NEXT:    br label [[OMP_INNER_FOR_INC:%.*]]
// CHECK2:       omp.inner.for.inc:
// CHECK2-NEXT:    [[TMP15:%.*]] = load i32, i32* [[DOTOMP_IV]], align 4
// CHECK2-NEXT:    [[ADD4:%.*]] = add nsw i32 [[TMP15]], 1
// CHECK2-NEXT:    store i32 [[ADD4]], i32* [[DOTOMP_IV]], align 4
// CHECK2-NEXT:    br label [[OMP_INNER_FOR_COND]]
// CHECK2:       omp.inner.for.end:
// CHECK2-NEXT:    br label [[OMP_DISPATCH_INC:%.*]]
// CHECK2:       omp.dispatch.inc:
// CHECK2-NEXT:    [[TMP16:%.*]] = load i32, i32* [[DOTOMP_LB]], align 4
// CHECK2-NEXT:    [[TMP17:%.*]] = load i32, i32* [[DOTOMP_STRIDE]], align 4
// CHECK2-NEXT:    [[ADD5:%.*]] = add nsw i32 [[TMP16]], [[TMP17]]
// CHECK2-NEXT:    store i32 [[ADD5]], i32* [[DOTOMP_LB]], align 4
// CHECK2-NEXT:    [[TMP18:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
// CHECK2-NEXT:    [[TMP19:%.*]] = load i32, i32* [[DOTOMP_STRIDE]], align 4
// CHECK2-NEXT:    [[ADD6:%.*]] = add nsw i32 [[TMP18]], [[TMP19]]
// CHECK2-NEXT:    store i32 [[ADD6]], i32* [[DOTOMP_UB]], align 4
// CHECK2-NEXT:    br label [[OMP_DISPATCH_COND]]
// CHECK2:       omp.dispatch.end:
// CHECK2-NEXT:    call void @__kmpc_for_static_fini(%struct.ident_t* @[[GLOB1]], i32 [[TMP3]])
// CHECK2-NEXT:    ret void
// CHECK2-LABEL: define {{[^@]+}}@__omp_outlined___wrapper
// CHECK2-SAME: (i16 zeroext [[TMP0:%.*]], i32 [[TMP1:%.*]]) #[[ATTR0]] {
// CHECK2-NEXT:  entry:
// CHECK2-NEXT:    [[DOTADDR:%.*]] = alloca i16, align 2
// CHECK2-NEXT:    [[DOTADDR1:%.*]] = alloca i32, align 4
// CHECK2-NEXT:    [[DOTZERO_ADDR:%.*]] = alloca i32, align 4
// CHECK2-NEXT:    [[GLOBAL_ARGS:%.*]] = alloca i8**, align 8
// CHECK2-NEXT:    store i32 0, i32* [[DOTZERO_ADDR]], align 4
// CHECK2-NEXT:    store i16 [[TMP0]], i16* [[DOTADDR]], align 2
// CHECK2-NEXT:    store i32 [[TMP1]], i32* [[DOTADDR1]], align 4
// CHECK2-NEXT:    call void @__kmpc_get_shared_variables(i8*** [[GLOBAL_ARGS]])
// CHECK2-NEXT:    [[TMP2:%.*]] = load i8**, i8*** [[GLOBAL_ARGS]], align 8
// CHECK2-NEXT:    [[TMP3:%.*]] = getelementptr inbounds i8*, i8** [[TMP2]], i64 0
// CHECK2-NEXT:    [[TMP4:%.*]] = bitcast i8** [[TMP3]] to [10 x i32]**
// CHECK2-NEXT:    [[TMP5:%.*]] = load [10 x i32]*, [10 x i32]** [[TMP4]], align 8
// CHECK2-NEXT:    [[TMP6:%.*]] = getelementptr inbounds i8*, i8** [[TMP2]], i64 1
// CHECK2-NEXT:    [[TMP7:%.*]] = bitcast i8** [[TMP6]] to i32**
// CHECK2-NEXT:    [[TMP8:%.*]] = load i32*, i32** [[TMP7]], align 8
// CHECK2-NEXT:    call void @__omp_outlined__(i32* [[DOTADDR1]], i32* [[DOTZERO_ADDR]], [10 x i32]* [[TMP5]], i32* [[TMP8]]) #[[ATTR3]]
// CHECK2-NEXT:    ret void
// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z9ftemplateIiET_i_l13
// CHECK-SAME: (i64 [[N:%.*]], [10 x i32]* nonnull align 4 dereferenceable(40) [[B:%.*]]) #[[ATTR0:[0-9]+]] {
// CHECK-NEXT:  entry:
// CHECK-NEXT:    [[N_ADDR:%.*]] = alloca i64, align 8
// CHECK-NEXT:    [[B_ADDR:%.*]] = alloca [10 x i32]*, align 8
// CHECK-NEXT:    [[CAPTURED_VARS_ADDRS:%.*]] = alloca [2 x i8*], align 8
// CHECK-NEXT:    store i64 [[N]], i64* [[N_ADDR]], align 8
// CHECK-NEXT:    store [10 x i32]* [[B]], [10 x i32]** [[B_ADDR]], align 8
// CHECK-NEXT:    [[CONV:%.*]] = bitcast i64* [[N_ADDR]] to i32*
// CHECK-NEXT:    [[TMP0:%.*]] = load [10 x i32]*, [10 x i32]** [[B_ADDR]], align 8
// CHECK-NEXT:    [[TMP1:%.*]] = call i32 @__kmpc_target_init(%struct.ident_t* @[[GLOB1:[0-9]+]], i8 1, i1 true, i1 true)
// CHECK-NEXT:    [[EXEC_USER_CODE:%.*]] = icmp eq i32 [[TMP1]], -1
// CHECK-NEXT:    br i1 [[EXEC_USER_CODE]], label [[USER_CODE_ENTRY:%.*]], label [[WORKER_EXIT:%.*]]
// CHECK:       user_code.entry:
// CHECK-NEXT:    [[D:%.*]] = call align 8 i8* @__kmpc_alloc_shared(i64 4)
// CHECK-NEXT:    [[D_ON_STACK:%.*]] = bitcast i8* [[D]] to i32*
// CHECK-NEXT:    [[TMP2:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB1]])
// CHECK-NEXT:    [[TMP3:%.*]] = load i32, i32* [[CONV]], align 4
// CHECK-NEXT:    store i32 [[TMP3]], i32* [[D_ON_STACK]], align 4
// CHECK-NEXT:    [[TMP4:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[CAPTURED_VARS_ADDRS]], i64 0, i64 0
// CHECK-NEXT:    [[TMP5:%.*]] = bitcast [10 x i32]* [[TMP0]] to i8*
// CHECK-NEXT:    store i8* [[TMP5]], i8** [[TMP4]], align 8
// CHECK-NEXT:    [[TMP6:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[CAPTURED_VARS_ADDRS]], i64 0, i64 1
// CHECK-NEXT:    [[TMP7:%.*]] = bitcast i32* [[D_ON_STACK]] to i8*
// CHECK-NEXT:    store i8* [[TMP7]], i8** [[TMP6]], align 8
// CHECK-NEXT:    [[TMP8:%.*]] = bitcast [2 x i8*]* [[CAPTURED_VARS_ADDRS]] to i8**
// CHECK-NEXT:    call void @__kmpc_parallel_51(%struct.ident_t* @[[GLOB1]], i32 [[TMP2]], i32 1, i32 -1, i32 -1, i8* bitcast (void (i32*, i32*, [10 x i32]*, i32*)* @__omp_outlined__ to i8*), i8* bitcast (void (i16, i32)* @__omp_outlined___wrapper to i8*), i8** [[TMP8]], i64 2)
// CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [10 x i32], [10 x i32]* [[TMP0]], i64 0, i64 3
// CHECK-NEXT:    [[TMP9:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
// CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP9]], 1
// CHECK-NEXT:    store i32 [[ADD]], i32* [[ARRAYIDX]], align 4
// CHECK-NEXT:    call void @__kmpc_free_shared(i8* [[D]], i64 4)
// CHECK-NEXT:    call void @__kmpc_target_deinit(%struct.ident_t* @[[GLOB1]], i8 1, i1 true)
// CHECK-NEXT:    ret void
// CHECK:       worker.exit:
// CHECK-NEXT:    ret void
//
//
// CHECK-LABEL: define {{[^@]+}}@__omp_outlined__
// CHECK-SAME: (i32* noalias [[DOTGLOBAL_TID_:%.*]], i32* noalias [[DOTBOUND_TID_:%.*]], [10 x i32]* nonnull align 4 dereferenceable(40) [[B:%.*]], i32* nonnull align 4 dereferenceable(4) [[D:%.*]]) #[[ATTR0]] {
// CHECK-NEXT:  entry:
// CHECK-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca i32*, align 8
// CHECK-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca i32*, align 8
// CHECK-NEXT:    [[B_ADDR:%.*]] = alloca [10 x i32]*, align 8
// CHECK-NEXT:    [[D_ADDR:%.*]] = alloca i32*, align 8
// CHECK-NEXT:    [[DOTOMP_IV:%.*]] = alloca i32, align 4
// CHECK-NEXT:    [[TMP:%.*]] = alloca i32, align 4
// CHECK-NEXT:    [[DOTOMP_LB:%.*]] = alloca i32, align 4
// CHECK-NEXT:    [[DOTOMP_UB:%.*]] = alloca i32, align 4
// CHECK-NEXT:    [[DOTOMP_STRIDE:%.*]] = alloca i32, align 4
// CHECK-NEXT:    [[DOTOMP_IS_LAST:%.*]] = alloca i32, align 4
// CHECK-NEXT:    [[I:%.*]] = alloca i32, align 4
// CHECK-NEXT:    store i32* [[DOTGLOBAL_TID_]], i32** [[DOTGLOBAL_TID__ADDR]], align 8
// CHECK-NEXT:    store i32* [[DOTBOUND_TID_]], i32** [[DOTBOUND_TID__ADDR]], align 8
// CHECK-NEXT:    store [10 x i32]* [[B]], [10 x i32]** [[B_ADDR]], align 8
// CHECK-NEXT:    store i32* [[D]], i32** [[D_ADDR]], align 8
// CHECK-NEXT:    [[TMP0:%.*]] = load [10 x i32]*, [10 x i32]** [[B_ADDR]], align 8
// CHECK-NEXT:    [[TMP1:%.*]] = load i32*, i32** [[D_ADDR]], align 8
// CHECK-NEXT:    store i32 0, i32* [[DOTOMP_LB]], align 4
// CHECK-NEXT:    store i32 9, i32* [[DOTOMP_UB]], align 4
// CHECK-NEXT:    store i32 1, i32* [[DOTOMP_STRIDE]], align 4
// CHECK-NEXT:    store i32 0, i32* [[DOTOMP_IS_LAST]], align 4
// CHECK-NEXT:    [[TMP2:%.*]] = load i32*, i32** [[DOTGLOBAL_TID__ADDR]], align 8
// CHECK-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
// CHECK-NEXT:    call void @__kmpc_for_static_init_4(%struct.ident_t* @[[GLOB2:[0-9]+]], i32 [[TMP3]], i32 33, i32* [[DOTOMP_IS_LAST]], i32* [[DOTOMP_LB]], i32* [[DOTOMP_UB]], i32* [[DOTOMP_STRIDE]], i32 1, i32 1)
// CHECK-NEXT:    br label [[OMP_DISPATCH_COND:%.*]]
// CHECK:       omp.dispatch.cond:
// CHECK-NEXT:    [[TMP4:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
// CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[TMP4]], 9
// CHECK-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
// CHECK:       cond.true:
// CHECK-NEXT:    br label [[COND_END:%.*]]
// CHECK:       cond.false:
// CHECK-NEXT:    [[TMP5:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
// CHECK-NEXT:    br label [[COND_END]]
// CHECK:       cond.end:
// CHECK-NEXT:    [[COND:%.*]] = phi i32 [ 9, [[COND_TRUE]] ], [ [[TMP5]], [[COND_FALSE]] ]
// CHECK-NEXT:    store i32 [[COND]], i32* [[DOTOMP_UB]], align 4
// CHECK-NEXT:    [[TMP6:%.*]] = load i32, i32* [[DOTOMP_LB]], align 4
// CHECK-NEXT:    store i32 [[TMP6]], i32* [[DOTOMP_IV]], align 4
// CHECK-NEXT:    [[TMP7:%.*]] = load i32, i32* [[DOTOMP_IV]], align 4
// CHECK-NEXT:    [[TMP8:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
// CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i32 [[TMP7]], [[TMP8]]
// CHECK-NEXT:    br i1 [[CMP1]], label [[OMP_DISPATCH_BODY:%.*]], label [[OMP_DISPATCH_END:%.*]]
// CHECK:       omp.dispatch.body:
// CHECK-NEXT:    br label [[OMP_INNER_FOR_COND:%.*]]
// CHECK:       omp.inner.for.cond:
// CHECK-NEXT:    [[TMP9:%.*]] = load i32, i32* [[DOTOMP_IV]], align 4
// CHECK-NEXT:    [[TMP10:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
// CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i32 [[TMP9]], [[TMP10]]
// CHECK-NEXT:    br i1 [[CMP2]], label [[OMP_INNER_FOR_BODY:%.*]], label [[OMP_INNER_FOR_END:%.*]]
// CHECK:       omp.inner.for.body:
// CHECK-NEXT:    [[TMP11:%.*]] = load i32, i32* [[DOTOMP_IV]], align 4
// CHECK-NEXT:    [[MUL:%.*]] = mul nsw i32 [[TMP11]], 1
// CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 0, [[MUL]]
// CHECK-NEXT:    store i32 [[ADD]], i32* [[I]], align 4
// CHECK-NEXT:    [[TMP12:%.*]] = load i32, i32* [[TMP1]], align 4
// CHECK-NEXT:    [[TMP13:%.*]] = load i32, i32* [[I]], align 4
// CHECK-NEXT:    [[IDXPROM:%.*]] = sext i32 [[TMP13]] to i64
// CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [10 x i32], [10 x i32]* [[TMP0]], i64 0, i64 [[IDXPROM]]
// CHECK-NEXT:    [[TMP14:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
// CHECK-NEXT:    [[ADD3:%.*]] = add nsw i32 [[TMP14]], [[TMP12]]
// CHECK-NEXT:    store i32 [[ADD3]], i32* [[ARRAYIDX]], align 4
// CHECK-NEXT:    br label [[OMP_BODY_CONTINUE:%.*]]
// CHECK:       omp.body.continue:
// CHECK-NEXT:    br label [[OMP_INNER_FOR_INC:%.*]]
// CHECK:       omp.inner.for.inc:
// CHECK-NEXT:    [[TMP15:%.*]] = load i32, i32* [[DOTOMP_IV]], align 4
// CHECK-NEXT:    [[ADD4:%.*]] = add nsw i32 [[TMP15]], 1
// CHECK-NEXT:    store i32 [[ADD4]], i32* [[DOTOMP_IV]], align 4
// CHECK-NEXT:    br label [[OMP_INNER_FOR_COND]]
// CHECK:       omp.inner.for.end:
// CHECK-NEXT:    br label [[OMP_DISPATCH_INC:%.*]]
// CHECK:       omp.dispatch.inc:
// CHECK-NEXT:    [[TMP16:%.*]] = load i32, i32* [[DOTOMP_LB]], align 4
// CHECK-NEXT:    [[TMP17:%.*]] = load i32, i32* [[DOTOMP_STRIDE]], align 4
// CHECK-NEXT:    [[ADD5:%.*]] = add nsw i32 [[TMP16]], [[TMP17]]
// CHECK-NEXT:    store i32 [[ADD5]], i32* [[DOTOMP_LB]], align 4
// CHECK-NEXT:    [[TMP18:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
// CHECK-NEXT:    [[TMP19:%.*]] = load i32, i32* [[DOTOMP_STRIDE]], align 4
// CHECK-NEXT:    [[ADD6:%.*]] = add nsw i32 [[TMP18]], [[TMP19]]
// CHECK-NEXT:    store i32 [[ADD6]], i32* [[DOTOMP_UB]], align 4
// CHECK-NEXT:    br label [[OMP_DISPATCH_COND]]
// CHECK:       omp.dispatch.end:
// CHECK-NEXT:    call void @__kmpc_for_static_fini(%struct.ident_t* @[[GLOB2]], i32 [[TMP3]])
// CHECK-NEXT:    ret void
//
//
// CHECK-LABEL: define {{[^@]+}}@__omp_outlined___wrapper
// CHECK-SAME: (i16 zeroext [[TMP0:%.*]], i32 [[TMP1:%.*]]) #[[ATTR3:[0-9]+]] {
// CHECK-NEXT:  entry:
// CHECK-NEXT:    [[DOTADDR:%.*]] = alloca i16, align 2
// CHECK-NEXT:    [[DOTADDR1:%.*]] = alloca i32, align 4
// CHECK-NEXT:    [[DOTZERO_ADDR:%.*]] = alloca i32, align 4
// CHECK-NEXT:    [[GLOBAL_ARGS:%.*]] = alloca i8**, align 8
// CHECK-NEXT:    store i16 [[TMP0]], i16* [[DOTADDR]], align 2
// CHECK-NEXT:    store i32 [[TMP1]], i32* [[DOTADDR1]], align 4
// CHECK-NEXT:    store i32 0, i32* [[DOTZERO_ADDR]], align 4
// CHECK-NEXT:    call void @__kmpc_get_shared_variables(i8*** [[GLOBAL_ARGS]])
// CHECK-NEXT:    [[TMP2:%.*]] = load i8**, i8*** [[GLOBAL_ARGS]], align 8
// CHECK-NEXT:    [[TMP3:%.*]] = getelementptr inbounds i8*, i8** [[TMP2]], i64 0
// CHECK-NEXT:    [[TMP4:%.*]] = bitcast i8** [[TMP3]] to [10 x i32]**
// CHECK-NEXT:    [[TMP5:%.*]] = load [10 x i32]*, [10 x i32]** [[TMP4]], align 8
// CHECK-NEXT:    [[TMP6:%.*]] = getelementptr inbounds i8*, i8** [[TMP2]], i64 1
// CHECK-NEXT:    [[TMP7:%.*]] = bitcast i8** [[TMP6]] to i32**
// CHECK-NEXT:    [[TMP8:%.*]] = load i32*, i32** [[TMP7]], align 8
// CHECK-NEXT:    call void @__omp_outlined__(i32* [[DOTADDR1]], i32* [[DOTZERO_ADDR]], [10 x i32]* [[TMP5]], i32* [[TMP8]]) #[[ATTR2:[0-9]+]]
// CHECK-NEXT:    ret void
//
",16278,True,5163.135270315656,median
"/***************************************************************************
 Copyright (c) 2016, Xilinx, Inc.
 All rights reserved.

 Redistribution and use in source and binary forms, with or without modification,
 are permitted provided that the following conditions are met:

 1. Redistributions of source code must retain the above copyright notice,
 this list of conditions and the following disclaimer.

 2. Redistributions in binary form must reproduce the above copyright notice,
 this list of conditions and the following disclaimer in the documentation
 and/or other materials provided with the distribution.

 3. Neither the name of the copyright holder nor the names of its contributors
 may be used to endorse or promote products derived from this software
 without specific prior written permission.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS"" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 ***************************************************************************/
#ifndef __XF_DENSE_NONPYR_OPTICAL_FLOW__
#define __XF_DENSE_NONPYR_OPTICAL_FLOW__
#include <stdio.h>
#include <string.h>
#include <ap_int.h>
#include <hls_stream.h>
#include <iostream>
#include <cmath>
#include <iomanip>
#include ""assert.h""
#include ""imgproc/xf_dense_npyr_optical_flow_types.h""
#include ""common/xf_common.h""

namespace xf{

// enable to run c-sim
//#define HLS_SIM

	// Custom low cost colorizer. Uses RGB to show 4 directions. For
	// simple demo purposes only. Real applications would take flow values and do
	// other useful analysis on them.
	static void getPseudoColorInt (pix_t pix, float fx, float fy, rgba_t& rgba)
	{
	  // normalization factor is key for good visualization. Make this auto-ranging
	  // or controllable from the host TODO
		  // const int normFac = 127/2;
		  const int normFac = 10;

	  int y = 127 + (int) (fy * normFac);
	  int x = 127 + (int) (fx * normFac);
	  if (y>255) y=255;
	  if (y<0) y=0;
	  if (x>255) x=255;
	  if (x<0) x=0;

	  rgb_t rgb;
	  if (x > 127) {
		if (y < 128) {
		  // 1 quad
		  rgb.r = x - 127 + (127-y)/2;
		  rgb.g = (127 - y)/2;
		  rgb.b = 0;
		} else {
		  // 4 quad
		  rgb.r = x - 127;
		  rgb.g = 0;
		  rgb.b = y - 127;
		}
	  } else {
		if (y < 128) {
		  // 2 quad
		  rgb.r = (127 - y)/2;
		  rgb.g = 127 - x + (127-y)/2;
		  rgb.b = 0;
		} else {
		  // 3 quad
		  rgb.r = 0;
		  rgb.g = 128 - x;
		  rgb.b = y - 127;
		}
	  }

	  rgba.r = pix/4 + 3*rgb.r/4; 
	  rgba.g = pix/4 + 3*rgb.g/4; 
	  rgba.b = pix/4 + 3*rgb.b/4;
	  rgba.a = 255;
	  // rgba.r = rgb.r; 
	  // rgba.g = rgb.g; 
	  // rgba.b = rgb.b ;
	}
	// read external array matB and stream. 
	// Can be simplified to a single loop with II=1 TODO
	//void readMatRows ( mywide_t< XF_NPIXPERCYCLE(NPC) >  *matB, hls::stream < mywide_t< XF_NPIXPERCYCLE(NPC) > >& pixStream)
	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE>
	static void readMatRows16 (ap_uint<16> *src, hls::stream < mywide_t< XF_NPIXPERCYCLE(NPC) > >& pixStream, int rows, int cols, int size)
	{
	unsigned int count = 0;
	  for (int i=0; i < size; i++) {
	  #pragma HLS LOOP_TRIPCOUNT min=1 max=COLS*ROWS/NPC
	  #pragma HLS PIPELINE
		  unsigned short t;
		  t = *(src + i);
		   mywide_t< XF_NPIXPERCYCLE(NPC) >  tmpData;
		  tmpData. data [0] = t & 0x00FF;
		  tmpData. data [1] = t >> 8;
		  pixStream. write (tmpData);
	  }

	}
	
	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE>
	static void writeMatRowsRGBA16 (hls::stream <rgba_t>& pixStream0, 
						   hls::stream <rgba_t>& pixStream1,
						   ap_uint<64>* dst, int rows, int cols, int size)
	{
	  for (int i=0; i < size; ++i) {
		#pragma HLS LOOP_TRIPCOUNT min=1 max=ROWS*COLS/NPC
		#pragma HLS PIPELINE
		  rgba_t d0 = pixStream0. read ();
		  rgba_t d1 = pixStream1. read ();

		  //unsigned int t1 = (unsigned int)d1.a << 24 | (unsigned int)d1.b << 16 | (unsigned int)d1.g << 8 | (unsigned int)d1.r;
		  //unsigned int t0 = (unsigned int)d0.a << 24 | (unsigned int)d0.b << 16 | (unsigned int)d0.g << 8 | (unsigned int)d0.r;
		  // who is at MSB? t0 or t1 TODO
		  //unsigned long long l = (unsigned long long) t1 << 32 | (unsigned long long) t0;

		  unsigned long long l = (unsigned long long)d1.a << 56 | (unsigned long long)d1.b << 48 |
								 (unsigned long long)d1.g << 40 | (unsigned long long)d1.r << 32 |
								 (unsigned long long)d0.a << 24 | (unsigned long long)d0.b << 16 |
								 (unsigned long long)d0.g << 8  | (unsigned long long)d0.r;
		  *(dst + i) =  l;
		}
	}
	
	// write rgba stream to external array dst. The ""a"" is just padding and is
	// unused
	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE>
	static void pack2Vectors (hls::stream <float>& flow0, 
						   hls::stream <float>& flow1,
						   ap_uint<64>* out_flow, int rows, int cols, int size)
	{
	  for (int i=0; i < size; i++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=ROWS*COLS/NPC
		#pragma HLS PIPELINE
		  float d0 = flow0.read();
		  float d1 = flow1.read();
		  ap_uint<32> *d0_int;
		  d0_int = (ap_uint<32> *)&d0;
		  ap_uint<32> *d1_int;
		  d1_int = (ap_uint<32> *)&d1;
		  //as 0th word will have d0_int and 1st word will have d1_int
		  ap_uint<64> l = ((unsigned long long)( *d1_int)<<32) | (unsigned long long)( *d0_int);
		  *(out_flow + i) =  l;
	  }
	}

	
	// Compute sums for bottom-right and top-right pixel and update the column sums.
	// Use column sums to update the integrals. Implements O(1) sliding window.
	//
	// TODO: 
	// 1. Dont need the entire column for img1Win and img2Win. Need only the kernel
	// 2. Full line buffer is not needed
	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE, bool USE_URAM>
	static void computeSums16 (hls::stream < mywide_t< XF_NPIXPERCYCLE(NPC) > > img1Col [(WINDOW_SIZE+1)], 
					  hls::stream < mywide_t< XF_NPIXPERCYCLE(NPC) > > img2Col [(WINDOW_SIZE+1)], 
					  hls::stream <int>& ixix_out0, 
					  hls::stream <int>& ixiy_out0, 
					  hls::stream <int>& iyiy_out0, 
					  hls::stream <int>& dix_out0, 
					  hls::stream <int>& diy_out0,

					  hls::stream <int>& ixix_out1, 
					  hls::stream <int>& ixiy_out1, 
					  hls::stream <int>& iyiy_out1, 
					  hls::stream <int>& dix_out1, 
					  hls::stream <int>& diy_out1, int rows, int cols, int size)
					  
	{
	  pix_t img1Col0 [(WINDOW_SIZE+1)], img2Col0 [(WINDOW_SIZE+1)];
	  pix_t img1Col1 [(WINDOW_SIZE+1)], img2Col1 [(WINDOW_SIZE+1)];
	#pragma HLS ARRAY_PARTITION variable=img1Col0 complete dim=0
	#pragma HLS ARRAY_PARTITION variable=img2Col0 complete dim=0
	#pragma HLS ARRAY_PARTITION variable=img1Col1 complete dim=0
	#pragma HLS ARRAY_PARTITION variable=img2Col1 complete dim=0

	  static pix_t img1Win [2 * (WINDOW_SIZE+1)], img2Win [1 * (WINDOW_SIZE+1)];
	#pragma HLS ARRAY_PARTITION variable=img1Win complete dim=0
	#pragma HLS ARRAY_PARTITION variable=img2Win complete dim=0
	  //static pix_t img1Win1 [2 * (WINDOW_SIZE+1)], img2Win1 [1 * (WINDOW_SIZE+1)];
	//#pragma HLS ARRAY_PARTITION variable=img1Win1 complete dim=0
	//#pragma HLS ARRAY_PARTITION variable=img2Win1 complete dim=0

	  static int ixix=0, ixiy=0, iyiy=0, dix=0, diy=0;

	  // column sums:
	  // need left-shift. Array-Part leads to FF with big Muxes. Try to do with
	  // classic array and pointer. Need current and current-WINDOW_SIZE ptrs
	  // For II=1 pipelining, need two read and 1 write ports. Simulating it with
	  // two arrays that have their write ports tied together.
	  // TODO need only MAX_WODTH/2. Have to adjust zIdx and nIdx as well
	  static int csIxixO [COLS/2], csIxiyO [COLS/2], csIyiyO [COLS/2], csDixO [COLS/2], csDiyO [COLS/2];
	  static int csIxixE [COLS/2], csIxiyE [COLS/2], csIyiyE [COLS/2], csDixE [COLS/2], csDiyE [COLS/2];

	  static int cbIxixO [COLS/2], cbIxiyO [COLS/2], cbIyiyO [COLS/2], cbDixO [COLS/2], cbDiyO [COLS/2];
	  static int cbIxixE [COLS/2], cbIxiyE [COLS/2], cbIyiyE [COLS/2], cbDixE [COLS/2], cbDiyE [COLS/2];

	  int zIdx=      - (WINDOW_SIZE/2-1);
	  int nIdx = zIdx + WINDOW_SIZE/2-1;

	#pragma HLS ARRAY_MAP variable=csIxixO instance=csO vertical
	#pragma HLS ARRAY_MAP variable=csIxiyO instance=csO vertical
	#pragma HLS ARRAY_MAP variable=csIyiyO instance=csO vertical
	#pragma HLS ARRAY_MAP variable=csDixO  instance=csO vertical
	#pragma HLS ARRAY_MAP variable=csDiyO  instance=csO vertical

	#pragma HLS ARRAY_MAP variable=csIxixE instance=csE vertical
	#pragma HLS ARRAY_MAP variable=csIxiyE instance=csE vertical
	#pragma HLS ARRAY_MAP variable=csIyiyE instance=csE vertical
	#pragma HLS ARRAY_MAP variable=csDixE  instance=csE vertical
	#pragma HLS ARRAY_MAP variable=csDiyE  instance=csE vertical

	#pragma HLS ARRAY_MAP variable=cbIxixO instance=cb vertical
	#pragma HLS ARRAY_MAP variable=cbIxiyO instance=cb vertical
	#pragma HLS ARRAY_MAP variable=cbIyiyO instance=cb vertical
	#pragma HLS ARRAY_MAP variable=cbDixO  instance=cb vertical
	#pragma HLS ARRAY_MAP variable=cbDiyO  instance=cb vertical
	#pragma HLS ARRAY_MAP variable=cbIxixE instance=cb vertical
	#pragma HLS ARRAY_MAP variable=cbIxiyE instance=cb vertical
	#pragma HLS ARRAY_MAP variable=cbIyiyE instance=cb vertical
	#pragma HLS ARRAY_MAP variable=cbDixE  instance=cb vertical
	#pragma HLS ARRAY_MAP variable=cbDiyE  instance=cb vertical

    if (USE_URAM) {
	#pragma HLS RESOURCE variable=csIxixO core=XPM_MEMORY uram
	#pragma HLS RESOURCE variable=csIxixE core=XPM_MEMORY uram
	#pragma HLS RESOURCE variable=cbIxixO core=XPM_MEMORY uram
    }
    else {
	#pragma HLS RESOURCE variable=csIxixO core=RAM_2P_BRAM
	#pragma HLS RESOURCE variable=csIxixE core=RAM_2P_BRAM
	#pragma HLS RESOURCE variable=cbIxixO core=RAM_2P_BRAM
    }

	#pragma HLS DEPENDENCE variable=csIxixO inter WAR false
	#pragma HLS DEPENDENCE variable=csIxiyO inter WAR false
	#pragma HLS DEPENDENCE variable=csIyiyO inter WAR false
	#pragma HLS DEPENDENCE variable=csDixO  inter WAR false
	#pragma HLS DEPENDENCE variable=csDiyO  inter WAR false

	#pragma HLS DEPENDENCE variable=csIxixE inter WAR false
	#pragma HLS DEPENDENCE variable=csIxiyE inter WAR false
	#pragma HLS DEPENDENCE variable=csIyiyE inter WAR false
	#pragma HLS DEPENDENCE variable=csDixE  inter WAR false
	#pragma HLS DEPENDENCE variable=csDiyE  inter WAR false


	#pragma HLS DEPENDENCE variable=cbIxixO inter WAR false
	#pragma HLS DEPENDENCE variable=cbIxiyO inter WAR false
	#pragma HLS DEPENDENCE variable=cbIyiyO inter WAR false
	#pragma HLS DEPENDENCE variable=cbDixO  inter WAR false
	#pragma HLS DEPENDENCE variable=cbDiyO  inter WAR false

	#pragma HLS DEPENDENCE variable=cbIxixE inter WAR false
	#pragma HLS DEPENDENCE variable=cbIxiyE inter WAR false
	#pragma HLS DEPENDENCE variable=cbIyiyE inter WAR false
	#pragma HLS DEPENDENCE variable=cbDixE  inter WAR false
	#pragma HLS DEPENDENCE variable=cbDiyE  inter WAR false

	  int csIxixR0, csIxiyR0, csIyiyR0, csDixR0, csDiyR0;
	  int csIxixR1, csIxiyR1, csIyiyR1, csDixR1, csDiyR1;

	  for (int r = 0; r < rows; r++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=ROWS
		for (int c = 0; c < cols/2; c++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=COLS/2
		  #pragma HLS PIPELINE

		  int csIxixL0 = 0, csIxiyL0 = 0, csIyiyL0 = 0, csDixL0  = 0, csDiyL0  = 0;
		  int csIxixL1 = 0, csIxiyL1 = 0, csIyiyL1 = 0, csDixL1  = 0, csDiyL1  = 0;

		  if (zIdx >= 0) {
	        int const zIdxPrev = zIdx==0 ? cols/2-1 : zIdx-1;
			csIxixL0 = csIxixO [zIdxPrev];
			csIxiyL0 = csIxiyO [zIdxPrev];
			csIyiyL0 = csIyiyO [zIdxPrev];
			csDixL0  = csDixO  [zIdxPrev];
			csDiyL0  = csDiyO  [zIdxPrev];

			csIxixL1 = csIxixE [zIdx];
			csIxiyL1 = csIxiyE [zIdx];
			csIyiyL1 = csIyiyE [zIdx];
			csDixL1  = csDixE  [zIdx];
			csDiyL1  = csDiyE  [zIdx];
		  }

		  for (int wr=0; wr<(WINDOW_SIZE+1); ++wr) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=WINDOW_SIZE+1
			 mywide_t< XF_NPIXPERCYCLE(NPC) >  tmp1 = img1Col [wr]. read ();
			img1Col0[wr] = tmp1. data [0];
			img1Col1[wr] = tmp1. data [1];

			 mywide_t< XF_NPIXPERCYCLE(NPC) >  tmp2 = img2Col [wr]. read ();
			img2Col0[wr] = tmp2. data [0];
			img2Col1[wr] = tmp2. data [1];
		  }

		  // p(x+1,y) and p(x-1,y)
		  int wrt=1;
		  int cIxTopR0 = (img1Col0 [wrt] - img1Win [wrt*2 + 2-2]) /2 ;
		  // p(x,y+1) and p(x,y-1)
		  int cIyTopR0 = (img1Win [ (wrt+1)*2 + 2-1] - img1Win [ (wrt-1)*2 + 2-1])  /2;
		  // p1(x,y) and p2(x,y)
		  int delTopR0 = img1Win [wrt*2 + 2-1] - img2Win [wrt*1 + 1-1];

		  int wrb = WINDOW_SIZE-1;
		  int cIxBotR0 = (img1Col0 [wrb] - img1Win [wrb*2 + 2-2]) /2 ;
		  int cIyBotR0 = (img1Win [ (wrb+1)*2 + 2-1] - img1Win [ (wrb-1)*2 + 2-1]) /2;
		  int delBotR0 = img1Win [wrb*2 + 2-1] - img2Win [wrb*1 + 1-1];
		  if (0 && r < WINDOW_SIZE) {
			cIxTopR0 = 0; cIyTopR0 = 0; delTopR0 = 0;
		  }
		  
		  // p(x+1,y) and p(x-1,y)
		  wrt=1;
		  int cIxTopR1 = (img1Col1 [wrt] - img1Win [wrt*2 + 2-1]) /2 ;
		  // p(x,y+1) and p(x,y-1)
		  int cIyTopR1 = (img1Col0 [wrt + 1] - img1Col0 [wrt - 1]) /2; 
		  // p1(x,y) and p2(x,y)
		  int delTopR1 = (img1Col0 [wrt] - img2Col0 [wrt]);

		  wrb = WINDOW_SIZE-1;
		  int cIxBotR1 = (img1Col1 [wrb] - img1Win [wrb*2 + 2-1]) /2 ;
		  int cIyBotR1 = (img1Col0 [wrb + 1] - img1Col0 [wrb - 1]) /2; 
		  int delBotR1 = (img1Col0 [wrb] - img2Col0 [wrb]);

		  csIxixR0 = cbIxixE [nIdx] + cIxBotR0 * cIxBotR0 - cIxTopR0 * cIxTopR0;
		  csIxiyR0 = cbIxiyE [nIdx] + cIxBotR0 * cIyBotR0 - cIxTopR0 * cIyTopR0;
		  csIyiyR0 = cbIyiyE [nIdx] + cIyBotR0 * cIyBotR0 - cIyTopR0 * cIyTopR0;
		  csDixR0  = cbDixE [nIdx]  + delBotR0 * cIxBotR0 - delTopR0 * cIxTopR0;
		  csDiyR0  = cbDiyE [nIdx]  + delBotR0 * cIyBotR0 - delTopR0 * cIyTopR0;

		  csIxixR1 = cbIxixO [nIdx] + cIxBotR1 * cIxBotR1 - cIxTopR1 * cIxTopR1;
		  csIxiyR1 = cbIxiyO [nIdx] + cIxBotR1 * cIyBotR1 - cIxTopR1 * cIyTopR1;
		  csIyiyR1 = cbIyiyO [nIdx] + cIyBotR1 * cIyBotR1 - cIyTopR1 * cIyTopR1;
		  csDixR1  = cbDixO  [nIdx] + delBotR1 * cIxBotR1 - delTopR1 * cIxTopR1;
		  csDiyR1  = cbDiyO  [nIdx] + delBotR1 * cIyBotR1 - delTopR1 * cIyTopR1;

		  int tmpixix0 = (csIxixR0 - csIxixL0);
		  int tmpixix1 = (csIxixR0 - csIxixL0) + (csIxixR1 - csIxixL1);
		  int tmpixiy0 = (csIxiyR0 - csIxiyL0);
		  int tmpixiy1 = (csIxiyR0 - csIxiyL0) + (csIxiyR1 - csIxiyL1);
		  int tmpiyiy0 = (csIyiyR0 - csIyiyL0);
		  int tmpiyiy1 = (csIyiyR0 - csIyiyL0) + (csIyiyR1 - csIyiyL1);
		  int tmpdix0  = (csDixR0 - csDixL0);
		  int tmpdix1  = (csDixR0 - csDixL0) + (csDixR1 - csDixL1);
		  int tmpdiy0  = (csDiyR0 - csDiyL0);
		  int tmpdiy1  = (csDiyR0 - csDiyL0) + (csDiyR1 - csDiyL1);

		  //ixix += (csIxixR0 - csIxixL0);
		  //ixiy += (csIxiyR0 - csIxiyL0);
		  //iyiy += (csIyiyR0 - csIyiyL0);
		  //dix += (csDixR0 - csDixL0);
		  //diy += (csDiyR0 - csDiyL0);

		  //ixix_out0. write (ixix);
		  //ixiy_out0. write (ixiy);
		  //iyiy_out0. write (iyiy);
		  //dix_out0. write (dix);
		  //diy_out0. write (diy);
		  ixix_out0. write (ixix + tmpixix0);
		  ixiy_out0. write (ixiy + tmpixiy0);
		  iyiy_out0. write (iyiy + tmpiyiy0);
		  dix_out0. write (dix + tmpdix0);
		  diy_out0. write (diy + tmpdiy0);

		  // now compute the second pixel
		  //ixix += (csIxixR1 - csIxixL1);
		  //ixiy += (csIxiyR1 - csIxiyL1);
		  //iyiy += (csIyiyR1 - csIyiyL1);
		  //dix += (csDixR1 - csDixL1);
		  //diy += (csDiyR1 - csDiyL1);
		  ixix += tmpixix1;
		  ixiy += tmpixiy1;
		  iyiy += tmpiyiy1;
		  dix += tmpdix1;
		  diy += tmpdiy1;

		  ixix_out1. write (ixix);
		  ixiy_out1. write (ixiy);
		  iyiy_out1. write (iyiy);
		  dix_out1. write (dix);
		  diy_out1. write (diy);

		  for (int i = 0; i < (WINDOW_SIZE+1); i++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=WINDOW_SIZE+1
			img1Win [i * 2] = img1Col0 [i];
			img1Win [i * 2 + 1] = img1Col1 [i];
			img2Win [i] = img2Col1 [i];
		  }

		  cbIxixE [nIdx] = csIxixR0;
		  cbIxiyE [nIdx] = csIxiyR0;
		  cbIyiyE [nIdx] = csIyiyR0;
		  cbDixE  [nIdx] = csDixR0;
		  cbDiyE  [nIdx] = csDiyR0;

		  csIxixE [nIdx] = csIxixR0;
		  csIxiyE [nIdx] = csIxiyR0;
		  csIyiyE [nIdx] = csIyiyR0;
		  csDixE  [nIdx] = csDixR0;
		  csDiyE  [nIdx] = csDiyR0;

		  cbIxixO [nIdx] = csIxixR1;
		  cbIxiyO [nIdx] = csIxiyR1;
		  cbIyiyO [nIdx] = csIyiyR1;
		  cbDixO  [nIdx] = csDixR1;
		  cbDiyO  [nIdx] = csDiyR1;

		  csIxixO [nIdx] = csIxixR1;
		  csIxiyO [nIdx] = csIxiyR1;
		  csIyiyO [nIdx] = csIyiyR1;
		  csDixO  [nIdx] = csDixR1;
		  csDiyO  [nIdx] = csDiyR1;

		  zIdx ++;
		  if (zIdx == cols/2) zIdx = 0;
		  nIdx ++;
		  if (nIdx == cols/2) nIdx = 0;
		}
	  }

	  // Cleanup. If kernel is called multiple times with different inputs, not
	  // cleaning these vars would pollute the subsequent frames.
	  // TODO zero in the line buffer instead, for r < WINDOW_SIZE
	  for (int r = 0; r < (WINDOW_SIZE+1); r++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=WINDOW_SIZE+1
		#pragma HLS UNROLL
		img1Win [r] = 0; img1Win [r+(WINDOW_SIZE+1)] = 0; img2Win [r] = 0;
		img1Col0 [r] =0; img2Col0 [r] =0;
		img1Col1 [r] =0; img2Col1 [r] =0;
	  }
	  for (int r=0; r < cols/2; ++r) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=COLS
		#pragma HLS PIPELINE
		csIxixO [r] = 0; csIxiyO [r] = 0; csIyiyO [r] = 0; csDixO [r] = 0; csDiyO [r] = 0;
		cbIxixO [r] = 0; cbIxiyO [r] = 0; cbIyiyO [r] = 0; cbDixO [r] = 0; cbDiyO [r] = 0;

		csIxixE [r] = 0; csIxiyE [r] = 0; csIyiyE [r] = 0; csDixE [r] = 0; csDiyE [r] = 0;
		cbIxixE [r] = 0; cbIxiyE [r] = 0; cbIyiyE [r] = 0; cbDixE [r] = 0; cbDiyE [r] = 0;
	  }
	  ixix=0; ixiy=0; iyiy=0; dix=0; diy=0;
	}

	// consume the integrals and compute flow vectors
	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE>
	static void computeFlow16 (hls::stream <int>& ixix, 
					  hls::stream <int>& ixiy, 
					  hls::stream <int>& iyiy, 
					  hls::stream <int>& dix, 
					  hls::stream <int>& diy, 
					  hls::stream <float>& fx_out, 
					  hls::stream <float>& fy_out, int rows, int cols, int size)
	{
	  for (int r = 0; r < rows; r++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=ROWS
		for (int c = 0; c < cols/2; c++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=COLS/2
		  #pragma HLS PIPELINE
		  int ixix_ = ixix. read ();
		  int ixiy_ = ixiy. read ();
		  int iyiy_ = iyiy. read ();
		  int dix_  = dix. read ();
		  int diy_  = diy. read ();
		  float fx_=0, fy_=0;

		  // matrix inv
		  float det = (float)ixix_ * iyiy_ - (float)ixiy_ * ixiy_;
		  if (det <= 1.0f || r<(WINDOW_SIZE) || c<((WINDOW_SIZE+1)/2)) {
			fx_ = 0.0;
			fy_ = 0.0;
		  } else {
			// res est: (dsp,ff,lut)
			// fdiv (0,748,800), fmul (3,143,139), fadd (2,306,246), fsub (2,306,246)
			// sitofp (0,229,365), fcmp (0,66,72), imul(1,0,0) (in cs)
			//float detInv = 1.0/det;
			float i00 = (float)iyiy_ / det;
			float i01 = (float) (-ixiy_) / det;
			float i10 = (float) (-ixiy_) / det;
			float i11 = (float)ixix_ / det;

			fx_ = i00 * dix_ + i01 * diy_;
			fy_ = i10 * dix_ + i11 * diy_;
		  }
		  fx_out. write (fx_);
		  fy_out. write (fy_);
		}
	  }
	}

	// convert flow values to visualizable pixel. For simple demo purposes only
	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE>
	static void getOutPix16 (hls::stream <float>& fx, 
					hls::stream <float>& fy, 
					hls::stream <rgba_t>& out_pix, int rows, int cols, int size)
	{
	  for (int r = 0; r < rows; r++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=ROWS
		for (int c = 0; c < cols/2; c++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=COLS/2
		  #pragma HLS PIPELINE
		  float fx_ = fx. read ();
		  float fy_ = fy. read ();

		  pix_t p_  = 0;
		  rgba_t out_pix_;
		  getPseudoColorInt (p_, fx_, fy_, out_pix_);

		  out_pix. write (out_pix_);
		}
	  }
	}

	// line buffer for both input images. Can be split to a fn that models a single
	// linebuffer
	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE, bool USE_URAM>
	static void lbWrapper16 (hls::stream < mywide_t< XF_NPIXPERCYCLE(NPC) > >& f0Stream, 
					hls::stream < mywide_t< XF_NPIXPERCYCLE(NPC) > >& f1Stream, 
					hls::stream < mywide_t< XF_NPIXPERCYCLE(NPC) > > img1Col[(WINDOW_SIZE+1)], 
					hls::stream < mywide_t< XF_NPIXPERCYCLE(NPC) > > img2Col[(WINDOW_SIZE+1)], int rows, int cols, int size)
	{
	  static pix_t lb1 [(WINDOW_SIZE+1)][COLS/XF_NPIXPERCYCLE(NPC)][XF_NPIXPERCYCLE(NPC)],
	               lb2 [(WINDOW_SIZE+1)][COLS/XF_NPIXPERCYCLE(NPC)][XF_NPIXPERCYCLE(NPC)];

    #pragma HLS ARRAY_MAP variable=lb1 instance=lbMap vertical
    #pragma HLS ARRAY_MAP variable=lb2 instance=lbMap vertical

    #pragma HLS ARRAY_RESHAPE variable=lb1 complete dim=1      
    #pragma HLS ARRAY_RESHAPE variable=lb2 complete dim=1
    #pragma HLS ARRAY_RESHAPE variable=lb1 complete dim=3      
    #pragma HLS ARRAY_RESHAPE variable=lb2 complete dim=3

    if (USE_URAM) {
    #pragma HLS RESOURCE variable=lb1 core=XPM_MEMORY uram
    #pragma HLS RESOURCE variable=lb2 core=XPM_MEMORY uram
    }

	  for (int r = 0; r < rows; r++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=ROWS
		  #pragma HLS LOOP_FLATTEN OFF
		for (int c = 0; c < cols/2; c++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=COLS/2
		  #pragma HLS pipeline
		  // shift up both linebuffers at col=c
		  for (int i = 0; i < ((WINDOW_SIZE+1) - 1); i++) {
			mywide_t< XF_NPIXPERCYCLE(NPC) > lb;

			for (int k = 0; k <XF_NPIXPERCYCLE(NPC); k++) {
			  lb.data[k] = lb1[i + 1][c][k];
			  lb1[i][c][k] = lb.data[k];
		    }
 			img1Col[i].write(lb);

			for (int k = 0; k <XF_NPIXPERCYCLE(NPC); k++) {
			  lb.data[k] = lb2[i + 1][c][k];
			  lb2[i][c][k] = lb.data[k];
		    }
 			img2Col[i].write(lb);
		  }

		  // read in the new pixels at col=c and row=bottom_of_lb
		   mywide_t< XF_NPIXPERCYCLE(NPC) >  pix0 = f0Stream. read ();
		  img1Col [(WINDOW_SIZE+1) - 1]. write (pix0);

		   mywide_t< XF_NPIXPERCYCLE(NPC) >  pix1 = f1Stream. read ();
		  img2Col [(WINDOW_SIZE+1) - 1]. write (pix1);

          for (int k = 0; k <XF_NPIXPERCYCLE(NPC); k++) {
		    lb1 [(WINDOW_SIZE+1) - 1][c][k] = pix0.data[k];
		    lb2 [(WINDOW_SIZE+1) - 1][c][k] = pix1.data[k];
		  }
		}
	  }


	  // cleanup
      for (int c = 0; c < cols/2; c++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=COLS/2
		  #pragma HLS PIPELINE
	    for (int r = 0; r < (WINDOW_SIZE+1); r++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=WINDOW_SIZE+1
          for (int k = 0; k <XF_NPIXPERCYCLE(NPC); k++) {
		    lb1[r][c][k] = 0;
		    lb2[r][c][k] = 0;
		  }
		}
	  }
	}

	// top level wrapper to avoid dataflow problems
	//void flowWrap (mywide_t frame0[NUM_WORDS], mywide_t frame1[NUM_WORDS], rgba2_t framef[NUM_WORDS])
	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE, bool USE_URAM>
	static void flowWrap16 (ap_uint<16> *frame0, ap_uint<16> *frame1, ap_uint<64> *flowx, ap_uint<64> *flowy, int rows, int cols, int size)
	{
	//#pragma HLS data_pack variable=frame0
	//#pragma HLS data_pack variable=frame1
	//#pragma HLS data_pack variable=framef

	#pragma HLS DATAFLOW

	  // ddr <-> kernel streams. Stream depths are probably too large and can be
	  // trimmed
	  hls::stream < mywide_t< XF_NPIXPERCYCLE(NPC) > > f0Stream, f1Stream;
	#pragma HLS data_pack variable=f0Stream
	#pragma HLS data_pack variable=f1Stream
	#pragma HLS STREAM variable=f0Stream depth=16
	#pragma HLS STREAM variable=f1Stream depth=16

	  // hls::stream <rgba_t> ff0Stream, ff1Stream;
	// #pragma HLS data_pack variable=ff0Stream
	// #pragma HLS data_pack variable=ff1Stream
	// #pragma HLS STREAM variable=ff0Stream depth=16
	// #pragma HLS STREAM variable=ff1Stream depth=16

	  hls::stream < mywide_t< XF_NPIXPERCYCLE(NPC) > > img1Col [(WINDOW_SIZE+1)], img2Col [(WINDOW_SIZE+1)];
	#pragma HLS data_pack variable=img1Col
	#pragma HLS data_pack variable=img2Col
	#pragma HLS STREAM variable=img1Col  depth=16
	#pragma HLS STREAM variable=img2Col  depth=16
	#pragma HLS ARRAY_PARTITION variable=img1Col complete dim=0
	#pragma HLS ARRAY_PARTITION variable=img2Col complete dim=0

	  hls::stream <int> ixix0, ixiy0, iyiy0, dix0, diy0;
	  hls::stream <float> fx0(""fx0""), fy0(""fy0"");
	#pragma HLS STREAM variable=ixix0 depth=16
	#pragma HLS STREAM variable=ixiy0 depth=16
	#pragma HLS STREAM variable=iyiy0 depth=16
	#pragma HLS STREAM variable=dix0 depth=16
	#pragma HLS STREAM variable=diy0 depth=16
	#pragma HLS STREAM variable=fx0  depth=16
	#pragma HLS STREAM variable=fy0  depth=16

	  hls::stream <int> ixix1, ixiy1, iyiy1, dix1, diy1;
	  hls::stream <float> fx1(""fx1""), fy1(""fy1"");
	#pragma HLS STREAM variable=ixix1 depth=16
	#pragma HLS STREAM variable=ixiy1 depth=16
	#pragma HLS STREAM variable=iyiy1 depth=16
	#pragma HLS STREAM variable=dix1 depth=16
	#pragma HLS STREAM variable=diy1 depth=16
	#pragma HLS STREAM variable=fx1  depth=16
	#pragma HLS STREAM variable=fy1  depth=16

	  readMatRows16<ROWS, COLS, NPC, WINDOW_SIZE> (frame0, f0Stream, rows, cols, size);
	  readMatRows16<ROWS, COLS, NPC, WINDOW_SIZE> (frame1, f1Stream, rows, cols, size);

	  lbWrapper16  <ROWS, COLS, NPC, WINDOW_SIZE, USE_URAM> (f0Stream, f1Stream, img1Col, img2Col, rows, cols, size);
	  computeSums16<ROWS, COLS, NPC, WINDOW_SIZE, USE_URAM> (img1Col, img2Col, 
				   ixix0, ixiy0, iyiy0, dix0, diy0, 
				   ixix1, ixiy1, iyiy1, dix1, diy1, rows, cols, size);

	  computeFlow16<ROWS, COLS, NPC, WINDOW_SIZE> (ixix0, ixiy0, iyiy0, dix0, diy0, fx0, fy0, rows, cols, size);
	  computeFlow16<ROWS, COLS, NPC, WINDOW_SIZE> (ixix1, ixiy1, iyiy1, dix1, diy1, fx1, fy1, rows, cols, size);

	  pack2Vectors<ROWS, COLS, NPC, WINDOW_SIZE> (fx0,  fx1, flowx, rows, cols, size);
	  pack2Vectors<ROWS, COLS, NPC, WINDOW_SIZE> (fy0,  fy1, flowy, rows, cols, size);
	}

	//----------------------------------------------------------------------------
	//----------------------------------------------------------------------------

	// external interface to the kernel. 
	//  frame0 - First input frame (grayscale 1 byte per pixel)
	//  frame1 - Second input frame (grayscale 1 byte per pixel)
	//  framef - Output frame with flows visualized. 3 bytes per pixel + 1 byte padding 
	//void fpga_optflow ( mywide_t< XF_NPIXPERCYCLE(NPC) >  *frame0,  mywide_t< XF_NPIXPERCYCLE(NPC) >  *frame1, rgba2_t *framef);
	// ushort = 16bits, 8 bits per grayscale pix, so two pix
	// ulonglong = 64 bits, 32 bits per color pixel (rgba), so two color pix
	//void fpga_optflow (unsigned short *frame0, unsigned short *frame1, unsigned long long *framef)
	//void fpga_optflow (unsigned short frame0[NUM_WORDS], unsigned short frame1[NUM_WORDS], unsigned long long framef[NUM_WORDS])
	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE, bool USE_URAM>
	static void fpga_optflow16 (ap_uint<16> *frame0, ap_uint<16> *frame1, ap_uint<64> *flowx, ap_uint<64> *flowy, int rows, int cols, int size)
	{
	#pragma HLS inline off

	  flowWrap16<ROWS, COLS, NPC, WINDOW_SIZE, USE_URAM> (frame0, frame1, flowx, flowy, rows, cols, size);

	  return;

	}
	
	// read external array matB and stream. 
	// Can be simplified to a single loop with II=1 TODO, hls::stream< mywide_t< XF_NPIXPERCYCLE(NPC) > > &frame1, hls::stream<rgba_t> &framef
	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE>
	static void readMatRows (ap_uint<8> *matB, hls::stream <pix_t>& pixStream, int rows, int cols, int size)
	{
	const int WORD_SIZE = (NPC == XF_NPPC1)? 1 : 2;
	  for (int i=0; i < size; i++) {
	  #pragma HLS LOOP_TRIPCOUNT min=1 max=COLS*ROWS/NPC
		#pragma HLS PIPELINE
		  mywide_t< XF_NPIXPERCYCLE(NPC) > tmpData;
		  tmpData.data[0] = *(matB + i);
		  for (int k=0; k < WORD_SIZE; ++k) {
			pixStream. write (tmpData. data [k]);
		  }
		}
	}

	// write rgba stream to external array dst. The ""a"" is just padding and is
	// unused
	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE>
	static void writeMatRowsRGBA (hls::stream <rgba_t>& pixStream, unsigned int *dst, int rows, int cols, int size)
	{
	  for (int i=0; i < size; i++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=ROWS*COLS/NPC
		#pragma HLS PIPELINE
		  rgba_t tmpData = pixStream. read ();
		  *(dst + i) = (unsigned int)tmpData.a << 24 | (unsigned int)tmpData.b << 16 | (unsigned int)tmpData.g << 8 | (unsigned int)tmpData.r;
		}
	}

	// Compute sums for bottom-right and top-right pixel and update the column sums.
	// Use column sums to update the integrals. Implements O(1) sliding window.
	//
	// TODO: 
	// 1. Dont need the entire column for img1Win and img2Win. Need only the kernel
	// 2. Full line buffer is not needed
	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE, bool USE_URAM>
	static void computeSums (hls::stream <pix_t> img1Col [(WINDOW_SIZE+1)], 
					  hls::stream <pix_t> img2Col [(WINDOW_SIZE+1)], 
					  hls::stream <int>& ixix_out, 
					  hls::stream <int>& ixiy_out, 
					  hls::stream <int>& iyiy_out, 
					  hls::stream <int>& dix_out, 
					  hls::stream <int>& diy_out, int rows, int cols, int size)
	{
	  pix_t img1Col_ [(WINDOW_SIZE+1)], img2Col_ [(WINDOW_SIZE+1)];
	#pragma HLS ARRAY_PARTITION variable=img1Col_ complete dim=0
	#pragma HLS ARRAY_PARTITION variable=img2Col_ complete dim=0

	  static pix_t img1Win [2 * (WINDOW_SIZE+1)], img2Win [1 * (WINDOW_SIZE+1)];
	  static int ixix=0, ixiy=0, iyiy=0, dix=0, diy=0;
	#pragma HLS ARRAY_PARTITION variable=img1Win complete dim=0
	#pragma HLS ARRAY_PARTITION variable=img2Win complete dim=0

	  // column sums:
	  // need left-shift. Array-Part leads to FF with big Muxes. Try to do with
	  // classic array and pointer. Need current and current-WINDOW_SIZE ptrs
	  // For II=1 pipelining, need two read and 1 write ports. Simulating it with
	  // two arrays that have their write ports tied together.
	  static int csIxix [COLS], csIxiy [COLS], csIyiy [COLS], csDix [COLS], csDiy [COLS];
	  static int cbIxix [COLS], cbIxiy [COLS], cbIyiy [COLS], cbDix [COLS], cbDiy [COLS];

	  int zIdx= - (WINDOW_SIZE-2);
	  int nIdx = zIdx + WINDOW_SIZE-2;

	#pragma HLS ARRAY_MAP variable=csIxix instance=cs vertical
	#pragma HLS ARRAY_MAP variable=csIxiy instance=cs vertical
	#pragma HLS ARRAY_MAP variable=csIyiy instance=cs vertical
	#pragma HLS ARRAY_MAP variable=csDix  instance=cs vertical
	#pragma HLS ARRAY_MAP variable=csDiy  instance=cs vertical

    if (USE_URAM) {
	#pragma HLS RESOURCE variable=csIxix core=XPM_MEMORY uram
    }
	else {
	#pragma HLS RESOURCE variable=csIxix core=RAM_2P_BRAM
	}
	
	#pragma HLS DEPENDENCE variable=csIxix inter WAR false
	#pragma HLS DEPENDENCE variable=csIxiy inter WAR false
	#pragma HLS DEPENDENCE variable=csIyiy inter WAR false
	#pragma HLS DEPENDENCE variable=csDix  inter WAR false
	#pragma HLS DEPENDENCE variable=csDiy  inter WAR false

	#pragma HLS ARRAY_MAP variable=cbIxix instance=cb vertical
	#pragma HLS ARRAY_MAP variable=cbIxiy instance=cb vertical
	#pragma HLS ARRAY_MAP variable=cbIyiy instance=cb vertical
	#pragma HLS ARRAY_MAP variable=cbDix  instance=cb vertical
	#pragma HLS ARRAY_MAP variable=cbDiy  instance=cb vertical

    if (USE_URAM) {
	#pragma HLS RESOURCE variable=cbIxix core=XPM_MEMORY uram
    }
    else {
	#pragma HLS RESOURCE variable=cbIxix core=RAM_2P_BRAM
    }

	#pragma HLS DEPENDENCE variable=cbIxix inter WAR false
	#pragma HLS DEPENDENCE variable=cbIxiy inter WAR false
	#pragma HLS DEPENDENCE variable=cbIyiy inter WAR false
	#pragma HLS DEPENDENCE variable=cbDix  inter WAR false
	#pragma HLS DEPENDENCE variable=cbDiy  inter WAR false

	  int csIxixR, csIxiyR, csIyiyR, csDixR, csDiyR;

	  for (int r = 0; r < rows; r++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=ROWS
		for (int c = 0; c < cols; c++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=COLS
		  #pragma HLS PIPELINE

		  int csIxixL = 0;
		  int csIxiyL = 0;
		  int csIyiyL = 0;
		  int csDixL  = 0;
		  int csDiyL  = 0;
		  if (zIdx >= 0) {
			csIxixL = csIxix [zIdx];
			csIxiyL = csIxiy [zIdx];
			csIyiyL = csIyiy [zIdx];
			csDixL  = csDix [zIdx];
			csDiyL  = csDiy [zIdx];
		  } 

		  for (int wr=0; wr<(WINDOW_SIZE+1); ++wr) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=WINDOW_SIZE+1
			img1Col_[wr] = img1Col [wr]. read (); 
			img2Col_[wr] = img2Col [wr]. read (); 
		  }

		  // p(x+1,y) and p(x-1,y)
		  int wrt=1;
		  int cIxTopR = (img1Col_ [wrt] - img1Win [wrt*2 + 2-2]) /2 ;
		  // p(x,y+1) and p(x,y-1)
		  int cIyTopR = (img1Win [ (wrt+1)*2 + 2-1] - img1Win [ (wrt-1)*2 + 2-1])  /2;
		  // p1(x,y) and p2(x,y)
		  int delTopR = img1Win [wrt*2 + 2-1] - img2Win [wrt*1 + 1-1];

		  int wrb = WINDOW_SIZE-1;
		  int cIxBotR = (img1Col_ [wrb] - img1Win [wrb*2 + 2-2]) /2 ;
		  int cIyBotR = (img1Win [ (wrb+1)*2 + 2-1] - img1Win [ (wrb-1)*2 + 2-1]) /2;
		  int delBotR = img1Win [wrb*2 + 2-1] - img2Win [wrb*1 + 1-1];
		  if (0 && r < WINDOW_SIZE) {
			cIxTopR = 0; cIyTopR = 0; delTopR = 0;
		  }

		  csIxixR = cbIxix [nIdx] + cIxBotR * cIxBotR - cIxTopR * cIxTopR;
		  csIxiyR = cbIxiy [nIdx] + cIxBotR * cIyBotR - cIxTopR * cIyTopR;
		  csIyiyR = cbIyiy [nIdx] + cIyBotR * cIyBotR - cIyTopR * cIyTopR;
		  csDixR  = cbDix [nIdx]  + delBotR * cIxBotR - delTopR * cIxTopR;
		  csDiyR  = cbDiy [nIdx]  + delBotR * cIyBotR - delTopR * cIyTopR;

		  ixix += (csIxixR - csIxixL);
		  ixiy += (csIxiyR - csIxiyL);
		  iyiy += (csIyiyR - csIyiyL);
		  dix += (csDixR - csDixL);
		  diy += (csDiyR - csDiyL);

		  ixix_out. write (ixix);
		  ixiy_out. write (ixiy);
		  iyiy_out. write (iyiy);
		  dix_out. write (dix);
		  diy_out. write (diy);

		  // we dont have the shifted pixel anymore to do overlay TODO
		  // img1Delayed. write (0);

		  for (int i = 0; i < (WINDOW_SIZE+1); i++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=WINDOW_SIZE+1
			img1Win [i * 2] = img1Win [i * 2 + 1];
		  }
		  for (int i=0; i < (WINDOW_SIZE+1); ++i) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=WINDOW_SIZE+1
			img1Win  [i*2 + 1] = img1Col_ [i];
			img2Win  [i] = img2Col_ [i];
		  }

		  cbIxix [nIdx] = csIxixR;
		  cbIxiy [nIdx] = csIxiyR;
		  cbIyiy [nIdx] = csIyiyR;
		  cbDix  [nIdx] = csDixR;
		  cbDiy  [nIdx] = csDiyR;

		  csIxix [nIdx] = csIxixR;
		  csIxiy [nIdx] = csIxiyR;
		  csIyiy [nIdx] = csIyiyR;
		  csDix  [nIdx] = csDixR;
		  csDiy  [nIdx] = csDiyR;
		  zIdx++;
		  if (zIdx == cols) zIdx = 0;
		  nIdx++;
		  if (nIdx == cols) nIdx = 0;
		}
	  }

	  // Cleanup. If kernel is called multiple times with different inputs, not
	  // cleaning these vars would pollute the subsequent frames.
	  // TODO zero in the line buffer instead, for r < WINDOW_SIZE
	  for (int r = 0; r < (WINDOW_SIZE+1); r++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=WINDOW_SIZE+1
		#pragma HLS UNROLL
		img1Win [r] = 0; img1Win [r+(WINDOW_SIZE+1)] = 0; img2Win [r] = 0;
		img1Col_ [r] =0; img2Col_ [r] =0;
	  }
	  for (int r=0; r < cols; ++r) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=COLS
		#pragma HLS PIPELINE
		csIxix [r] = 0; csIxiy [r] = 0; csIyiy [r] = 0; csDix [r] = 0; csDiy [r] = 0;
		cbIxix [r] = 0; cbIxiy [r] = 0; cbIyiy [r] = 0; cbDix [r] = 0; cbDiy [r] = 0;
	  }
	  ixix=0; ixiy=0; iyiy=0; dix=0; diy=0;
	}

	// consume the integrals and compute flow vectors
	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE>
	static void computeFlow (hls::stream <int>& ixix, 
					  hls::stream <int>& ixiy, 
					  hls::stream <int>& iyiy, 
					  hls::stream <int>& dix, 
					  hls::stream <int>& diy, 
					  hls::stream <float> &fx_out,
					  hls::stream <float> &fy_out, int rows, int cols, int size)
	{
	  for (int r = 0; r < rows; r++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=ROWS
		for (int c = 0; c < cols; c++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=COLS
		  #pragma HLS PIPELINE
		  int ixix_ = ixix. read ();
		  int ixiy_ = ixiy. read ();
		  int iyiy_ = iyiy. read ();
		  int dix_  = dix. read ();
		  int diy_  = diy. read ();
		  float fx_=0, fy_=0;

		  // matrix inv
		  float det = (float)ixix_ * iyiy_ - (float)ixiy_ * ixiy_;
		  if (det <= 1.0f || r<(WINDOW_SIZE) || c<(WINDOW_SIZE+1)) {
			fx_ = 0.0;
			fy_ = 0.0;
		  } else {
			// res est: (dsp,ff,lut)
			// fdiv (0,748,800), fmul (3,143,139), fadd (2,306,246), fsub (2,306,246)
			// sitofp (0,229,365), fcmp (0,66,72), imul(1,0,0) (in cs)
			//float detInv = 1.0/det;
			float i00 = (float)iyiy_ / det;
			float i01 = (float) (-ixiy_) / det;
			float i10 = (float) (-ixiy_) / det;
			float i11 = (float)ixix_ / det;

			fx_ = i00 * dix_ + i01 * diy_;
			fy_ = i10 * dix_ + i11 * diy_;
		  }
		  fx_out.write(fx_);
		  fy_out.write(fy_);
		}
	  }
	}

	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE>
	static void writeOutput8 (hls::stream <float> &fx_in, hls::stream <float> &fy_in, float *fx_out, float *fy_out, int size)
	{
	  for (int r = 0; r < size; r++) {
	  #pragma HLS LOOP_TRIPCOUNT min=1 max=ROWS*COLS
	  #pragma HLS PIPELINE
		  *(fx_out + r) = fx_in.read();
		  *(fy_out + r) = fy_in.read();
	  }
	}
	
	// convert flow values to visualizable pixel. For simple demo purposes only
	template<int ROWS, int COLS, int NPC>
	static void getOutPix (
					float *fx, 
					float *fy, 
					pix_t *p,
					hls::stream <rgba_t>& out_pix, int rows, int cols, int size)
	{
	  for (int r = 0; r < rows; r++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=ROWS
		for (int c = 0; c < cols; c++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=COLS
		  #pragma HLS PIPELINE
		  float fx_ = *(fx + r*cols + c);
		  float fy_ = *(fy + r*cols + c);

		  pix_t p_  = *(p + r*cols + c);
		  rgba_t out_pix_;
		  getPseudoColorInt (p_, fx_, fy_, out_pix_);

		  out_pix. write (out_pix_);
		}
	  }
	}

	// line buffer for both input images. Can be split to a fn that models a single
	// linebuffer
	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE, bool USE_URAM>
	static void lbWrapper (hls::stream <pix_t>& f0Stream, 
					hls::stream <pix_t>& f1Stream, 
					hls::stream <pix_t> img1Col[(WINDOW_SIZE+1)], 
					hls::stream <pix_t> img2Col[(WINDOW_SIZE+1)], int rows, int cols, int size)
	{
	static pix_t lb1 [(WINDOW_SIZE+1)][COLS], lb2 [(WINDOW_SIZE+1)][COLS];
	#pragma HLS ARRAY_MAP variable=lb1 instance=lbMap vertical
	#pragma HLS ARRAY_MAP variable=lb2 instance=lbMap vertical
	#pragma HLS ARRAY_RESHAPE variable=lb1 complete dim=1
	#pragma HLS ARRAY_RESHAPE variable=lb2 complete dim=1
	if (USE_URAM) {
	#pragma HLS RESOURCE variable=lb1 core=XPM_MEMORY uram
	#pragma HLS RESOURCE variable=lb2 core=XPM_MEMORY uram
	}

	  for (int r = 0; r < rows; r++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=ROWS
		  #pragma HLS LOOP_FLATTEN OFF
		for (int c = 0; c < cols; c++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=COLS
		  #pragma HLS pipeline

		  // shift up both linebuffers at col=c
		  for (int i = 0; i < (WINDOW_SIZE+1) - 1; i++) {
			lb1 [i][c] = lb1 [i + 1][c];
			img1Col [i]. write (lb1 [i][c]);

			lb2 [i][c] = lb2 [i+1][c];
			img2Col [i]. write (lb2 [i][c]);
		  }

		  // read in the new pixels at col=c and row=bottom_of_lb
		  pix_t pix0 = f0Stream. read ();
		  lb1 [(WINDOW_SIZE+1) - 1][c] = pix0;
		  img1Col [(WINDOW_SIZE+1) - 1]. write (pix0);

		  pix_t pix1 = f1Stream. read ();
		  lb2 [(WINDOW_SIZE+1) -1][c] = pix1;
		  img2Col [(WINDOW_SIZE+1) - 1]. write (pix1);
		}
	  }


	  // cleanup
      for (int c = 0; c < cols; c++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=COLS
		  #pragma HLS PIPELINE
        for (int r = 0; r < (WINDOW_SIZE+1); r++) {
		  #pragma HLS LOOP_TRIPCOUNT min=1 max=WINDOW_SIZE+1
		  lb1 [r][c] = 0;
		  lb2 [r][c] = 0;
		}
	  }
	}

	// top level wrapper to avoid dataflow problems
	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE, bool USE_URAM>
	static void flowWrap (ap_uint<8> *frame0, ap_uint<8> *frame1, float *flowx, float *flowy, int rows, int cols, int size)
	{
	#pragma HLS inline off
	#pragma HLS DATAFLOW

	  // ddr <-> kernel streams. Stream depths are probably too large and can be
	  // trimmed
	  hls::stream <pix_t> f0Stream (""f0Stream""), f1Stream (""f1Stream"");
	  hls::stream <pix_t> f0Delayed (""f0Delayed"");
	#pragma HLS STREAM variable=f0Stream depth=16
	#pragma HLS STREAM variable=f1Stream depth=16
	// #pragma HLS STREAM variable=f0Delayed depth=128

	  // hls::stream <rgba_t> ffStream (""ffStream"");
	// #pragma HLS data_pack variable=ffStream
	// #pragma HLS STREAM variable=ffStream depth=16

	  hls::stream <pix_t> img1Col [(WINDOW_SIZE+1)], img2Col [(WINDOW_SIZE+1)];
	  hls::stream <int> ixix, ixiy, iyiy, dix, diy;
	  hls::stream <float> fx, fy;

	#pragma HLS STREAM variable=ixix depth=16
	#pragma HLS STREAM variable=ixiy depth=16
	#pragma HLS STREAM variable=iyiy depth=16
	#pragma HLS STREAM variable=dix depth=16
	#pragma HLS STREAM variable=diy depth=16
	// #pragma HLS STREAM variable=fx  depth=16
	// #pragma HLS STREAM variable=fy  depth=16
	#pragma HLS STREAM variable=img1Col  depth=16
	#pragma HLS STREAM variable=img2Col  depth=16

	#pragma HLS ARRAY_PARTITION variable=img1Col complete dim=0
	#pragma HLS ARRAY_PARTITION variable=img2Col complete dim=0

		readMatRows<ROWS, COLS, NPC, WINDOW_SIZE> (frame0, f0Stream, rows, cols, size);
		readMatRows<ROWS, COLS, NPC, WINDOW_SIZE> (frame1, f1Stream, rows, cols, size);

		lbWrapper  <ROWS, COLS, NPC, WINDOW_SIZE, USE_URAM> (f0Stream, f1Stream, img1Col, img2Col, rows, cols, size);
	  
		computeSums<ROWS, COLS, NPC, WINDOW_SIZE, USE_URAM> (img1Col, img2Col, ixix, ixiy, iyiy, dix, diy, rows, cols, size);
	  
		computeFlow<ROWS, COLS, NPC, WINDOW_SIZE> (ixix, ixiy, iyiy, dix, diy, fx, fy, rows, cols, size);

	    writeOutput8<ROWS, COLS, NPC, WINDOW_SIZE> (fx, fy, flowx, flowy, size);
	}

	//----------------------------------------------------------------------------
	//----------------------------------------------------------------------------

	// external interface to the kernel. 
	//  frame0 - First input frame (grayscale 1 byte per pixel)
	//  frame1 - Second input frame (grayscale 1 byte per pixel)
	//  framef - Output frame with flows visualized. 3 bytes per pixel + 1 byte padding 
	template<int ROWS, int COLS, int NPC, int WINDOW_SIZE, bool USE_URAM>
	static void fpga_optflow8 (ap_uint<8> *frame0, ap_uint<8> *frame1, float *flowx, float *flowy, int rows, int cols, int size)
	{
	#pragma HLS inline off

	  flowWrap<ROWS, COLS, NPC, WINDOW_SIZE, USE_URAM>(frame0, frame1, flowx, flowy, rows, cols, size);

	  return;

	}
// #pragma SDS data data_mover(""frame0.data"":AXIDMA_SIMPLE)
// #pragma SDS data data_mover(""frame1.data"":AXIDMA_SIMPLE)
// #pragma SDS data data_mover(""framef.data"":AXIDMA_SG)
#pragma SDS data mem_attribute(""frame0.data"":NON_CACHEABLE|PHYSICAL_CONTIGUOUS)
#pragma SDS data mem_attribute(""frame1.data"":NON_CACHEABLE|PHYSICAL_CONTIGUOUS)
#pragma SDS data mem_attribute(""flowx.data"":NON_CACHEABLE|PHYSICAL_CONTIGUOUS)
#pragma SDS data mem_attribute(""flowy.data"":NON_CACHEABLE|PHYSICAL_CONTIGUOUS)
#pragma SDS data access_pattern(""frame0.data"":SEQUENTIAL)
#pragma SDS data access_pattern(""frame1.data"":SEQUENTIAL)
#pragma SDS data access_pattern(""flowx.data"":SEQUENTIAL)
#pragma SDS data access_pattern(""flowy.data"":SEQUENTIAL)
#pragma SDS data copy(""frame0.data""[0:""frame0.size""])
#pragma SDS data copy(""frame1.data""[0:""frame1.size""])
#pragma SDS data copy(""flowx.data""[0:""flowx.size""])
#pragma SDS data copy(""flowy.data""[0:""flowy.size""])
template<int WINDOW_SIZE, int TYPE, int ROWS, int COLS, int NPC, bool USE_URAM = false>
void DenseNonPyrLKOpticalFlow (xf::Mat<TYPE, ROWS, COLS, NPC> & frame0, xf::Mat<TYPE, ROWS, COLS, NPC> & frame1, xf::Mat<XF_32FC1, ROWS, COLS, NPC> & flowx, xf::Mat<XF_32FC1, ROWS, COLS, NPC> & flowy)
{
	if(NPC==XF_NPPC1)
	{
		fpga_optflow8 <ROWS, COLS, NPC, WINDOW_SIZE, USE_URAM> ( (ap_uint<8> *) frame0.data, (ap_uint<8> *)frame1.data, (float *)flowx.data, (float *)flowy.data, frame0.rows, frame0.cols, frame0.size);
	}
	else
	{
		fpga_optflow16 <ROWS, COLS, NPC, WINDOW_SIZE, USE_URAM> ( (ap_uint<16> *) frame0.data, (ap_uint<16> *) frame1.data, (ap_uint<64> *)flowx.data, (ap_uint<64> *)flowy.data, frame0.rows, frame0.cols, frame0.size);
	}
}
}
#endif
",16189,True,3456.1887410683953,median
"= v1.EgressNetworkPolicy
{product-author}
{product-version}
:data-uri:
:icons:
:toc: macro
:toc-title:
:toclevels: 2

toc::[]

== Description
[%hardbreaks]
EgressNetworkPolicy describes the current egress network policy for a Namespace. When using the 'redhat/openshift-ovs-multitenant' network plugin, traffic from a pod to an IP address outside the cluster will be checked against each EgressNetworkPolicyRule in the pod's namespace's EgressNetworkPolicy, in order. If no rule matches (or no EgressNetworkPolicy is present) then the traffic will be allowed by default.

== Object Schema
Expand or mouse-over a field for more information about it.

++++
<pre>
<div style=""margin-left:13px;""><span title=""(string) APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources"">apiVersion</span>:
</div><div style=""margin-left:13px;""><span title=""(string) Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><details open><summary><span title=""(v1.ObjectMeta) metadata for EgressNetworkPolicy"">metadata</span>:
</summary><details><summary>  <span title=""(object) Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations"">annotations</span>:
</summary><div style=""margin-left:13px;"">    <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) The name of the cluster which the object belongs to. This is used to distinguish resources with same name and namespace in different clusters. This field is not set anywhere right now and apiserver is going to ignore it if set in create or update request."">clusterName</span>:
</div><div style=""margin-left:13px;"">  <span title=""(v1.Time) CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.

Populated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata"">creationTimestamp</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only."">deletionGracePeriodSeconds</span>:
</div><div style=""margin-left:13px;"">  <span title=""(v1.Time) DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.

Populated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata"">deletionTimestamp</span>:
</div><details><summary>  <span title=""(array) Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed."">finalizers</span>:
</summary><div style=""margin-left:13px;"">  - <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.

If this field is specified and the generated name exists, the server will NOT return a 409 - instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, and the client should retry (optionally after the time indicated in the Retry-After header).

Applied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#idempotency"">generateName</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) A sequence number representing a specific generation of the desired state. Populated by the system. Read-only."">generation</span>:
</div><details><summary>  <span title=""(v1.Initializers) An initializer is a controller which enforces some system invariant at object creation time. This field is a list of initializers that have not yet acted on this object. If nil or empty, this object has been completely initialized. Otherwise, the object is considered uninitialized and is hidden (in list/watch and get calls) from clients that haven&#39;t explicitly asked to observe uninitialized objects.

When an object is created, the system will populate this list with the current set of initializers. Only privileged users may set or modify this list. Once it is empty, it may not be modified further by any user."">initializers</span>:
</summary><details><summary>    <span title=""(array) Pending is a list of initializers that must execute in order before this object is visible. When the last pending initializer is removed, and no failing result is set, the initializers struct will be set to nil and the object is considered as initialized and visible to all clients."">pending</span>:
</summary><div style=""margin-left:13px;"">    - <span title=""(string) name of the process that is responsible for initializing this object."">name</span>:
</div></details><details><summary>    <span title=""(v1.Status) If result is set with the Failure field, the object will be persisted to storage and then deleted, ensuring that other clients can observe the deletion."">result</span>:
</summary><div style=""margin-left:13px;"">      <span title=""(string) APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources"">apiVersion</span>:
</div><div style=""margin-left:13px;"">      <span title=""(integer) Suggested HTTP return code for this status, 0 if not set."">code</span>:
</div><details><summary>      <span title=""(v1.StatusDetails) Extended data associated with the reason.  Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type."">details</span>:
</summary><details><summary>        <span title=""(array) The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes."">causes</span>:
</summary><div style=""margin-left:13px;"">        - <span title=""(string) The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed.  Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.

Examples:
  &#34;name&#34; - the field &#34;name&#34; on the current resource
  &#34;items[0].name&#34; - the field &#34;name&#34; on the first array entry in &#34;items&#34;"">field</span>:
</div><div style=""margin-left:13px;"">          <span title=""(string) A human-readable description of the cause of the error.  This field may be presented as-is to a reader."">message</span>:
</div><div style=""margin-left:13px;"">          <span title=""(string) A machine-readable description of the cause of the error. If this value is empty there is no information available."">reason</span>:
</div></details><div style=""margin-left:13px;"">        <span title=""(string) The group attribute of the resource associated with the status StatusReason."">group</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described)."">name</span>:
</div><div style=""margin-left:13px;"">        <span title=""(integer) If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action."">retryAfterSeconds</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) UID of the resource. (when there is a single resource which can be described). More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><div style=""margin-left:13px;"">      <span title=""(string) Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">      <span title=""(string) A human-readable description of the status of this operation."">message</span>:
</div><details><summary>      <span title=""(v1.ListMeta) Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">metadata</span>:
</summary><div style=""margin-left:13px;"">        <span title=""(string) continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response."">continue</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) String that identifies the server&#39;s internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency"">resourceVersion</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) selfLink is a URL representing this object. Populated by the system. Read-only."">selfLink</span>:
</div></details><div style=""margin-left:13px;"">      <span title=""(string) A machine-readable description of why this operation is in the &#34;Failure&#34; status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it."">reason</span>:
</div><div style=""margin-left:13px;"">      <span title=""(string) Status of the operation. One of: &#34;Success&#34; or &#34;Failure&#34;. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#spec-and-status"">status</span>:
</div></details></details><details><summary>  <span title=""(object) Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels"">labels</span>:
</summary><div style=""margin-left:13px;"">    <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names"">name</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Namespace defines the space within each name must be unique. An empty namespace is equivalent to the &#34;default&#34; namespace, but &#34;default&#34; is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.

Must be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces"">namespace</span>:
</div><details><summary>  <span title=""(array) List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller."">ownerReferences</span>:
</summary><div style=""margin-left:13px;"">  - <span title=""(string) API version of the referent."">apiVersion</span>:
</div><div style=""margin-left:13px;"">    <span title=""(boolean) If true, AND if the owner has the &#34;foregroundDeletion&#34; finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. Defaults to false. To set this field, a user needs &#34;delete&#34; permission of the owner, otherwise 422 (Unprocessable Entity) will be returned."">blockOwnerDeletion</span>:
</div><div style=""margin-left:13px;"">    <span title=""(boolean) If true, this reference points to the managing controller."">controller</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names"">name</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.

Populated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency"">resourceVersion</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) SelfLink is a URL representing this object. Populated by the system. Read-only."">selfLink</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.

Populated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><details open><summary><span title=""(v1.EgressNetworkPolicySpec) spec is the specification of the current egress network policy"">spec</span>:
</summary><details><summary>  <span title=""(array) egress contains the list of egress policy rules"">egress</span>:
</summary><details><summary>  - <span title=""(v1.EgressNetworkPolicyPeer) to is the target that traffic is allowed/denied to"">to</span>:
</summary><div style=""margin-left:13px;"">  -   <span title=""(string) cidrSelector is the CIDR range to allow/deny traffic to. If this is set, dnsName must be unset"">cidrSelector</span>:
</div><div style=""margin-left:13px;"">      <span title=""(string) dnsName is the domain name to allow/deny traffic to. If this is set, cidrSelector must be unset"">dnsName</span>:
</div></details><div style=""margin-left:13px;"">    <span title=""(string) type marks this as an &#34;Allow&#34; or &#34;Deny&#34; rule"">type</span>:
</div></details></details>
</pre>
++++

== Operations

[[Post-apis-network.openshift.io-v1-namespaces-namespace-egressnetworkpolicies]]
=== Create a EgressNetworkPolicy in a namespace
Create an EgressNetworkPolicy

==== HTTP request
----
POST /apis/network.openshift.io/v1/namespaces/$NAMESPACE/egressnetworkpolicies HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""EgressNetworkPolicy"",
  ""apiVersion"": ""network.openshift.io/v1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X POST \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/apis/network.openshift.io/v1/namespaces/$NAMESPACE/egressnetworkpolicies <<'EOF'
{
  ""kind"": ""EgressNetworkPolicy"",
  ""apiVersion"": ""network.openshift.io/v1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.EgressNetworkPolicy
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.EgressNetworkPolicy
|201 Created|v1.EgressNetworkPolicy
|202 Accepted|v1.EgressNetworkPolicy
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Get-apis-network.openshift.io-v1-namespaces-namespace-egressnetworkpolicies-name]]
=== Get a EgressNetworkPolicy in a namespace
Read the specified EgressNetworkPolicy

==== HTTP request
----
GET /apis/network.openshift.io/v1/namespaces/$NAMESPACE/egressnetworkpolicies/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/network.openshift.io/v1/namespaces/$NAMESPACE/egressnetworkpolicies/$NAME
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the EgressNetworkPolicy
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|exact|Should the export be exact.  Exact export maintains cluster-specific fields like 'Namespace'.
|export|Should this value be exported.  Export strips fields that a user can not specify.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.EgressNetworkPolicy
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Get-apis-network.openshift.io-v1-egressnetworkpolicies]]
=== Get all EgressNetworkPolicies
List or watch objects of kind EgressNetworkPolicy

==== HTTP request
----
GET /apis/network.openshift.io/v1/egressnetworkpolicies HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/network.openshift.io/v1/egressnetworkpolicies
----

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|pretty|If 'true', then the output is pretty printed.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.EgressNetworkPolicyList
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-apis-network.openshift.io-v1-namespaces-namespace-egressnetworkpolicies]]
=== Get all EgressNetworkPolicies in a namespace
List or watch objects of kind EgressNetworkPolicy

==== HTTP request
----
GET /apis/network.openshift.io/v1/namespaces/$NAMESPACE/egressnetworkpolicies HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/network.openshift.io/v1/namespaces/$NAMESPACE/egressnetworkpolicies
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.EgressNetworkPolicyList
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-apis-network.openshift.io-v1-watch-namespaces-namespace-egressnetworkpolicies-name]]
=== Watch a EgressNetworkPolicy in a namespace
Watch changes to an object of kind EgressNetworkPolicy

==== HTTP request
----
GET /apis/network.openshift.io/v1/watch/namespaces/$NAMESPACE/egressnetworkpolicies/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/network.openshift.io/v1/watch/namespaces/$NAMESPACE/egressnetworkpolicies/$NAME
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the EgressNetworkPolicy
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|pretty|If 'true', then the output is pretty printed.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.WatchEvent
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-apis-network.openshift.io-v1-watch-egressnetworkpolicies]]
=== Watch all EgressNetworkPolicies
Watch individual changes to a list of EgressNetworkPolicy

==== HTTP request
----
GET /apis/network.openshift.io/v1/watch/egressnetworkpolicies HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/network.openshift.io/v1/watch/egressnetworkpolicies
----

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|pretty|If 'true', then the output is pretty printed.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.WatchEvent
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-apis-network.openshift.io-v1-watch-namespaces-namespace-egressnetworkpolicies]]
=== Watch all EgressNetworkPolicies in a namespace
Watch individual changes to a list of EgressNetworkPolicy

==== HTTP request
----
GET /apis/network.openshift.io/v1/watch/namespaces/$NAMESPACE/egressnetworkpolicies HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/network.openshift.io/v1/watch/namespaces/$NAMESPACE/egressnetworkpolicies
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|pretty|If 'true', then the output is pretty printed.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.WatchEvent
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Put-apis-network.openshift.io-v1-namespaces-namespace-egressnetworkpolicies-name]]
=== Update a EgressNetworkPolicy in a namespace
Replace the specified EgressNetworkPolicy

==== HTTP request
----
PUT /apis/network.openshift.io/v1/namespaces/$NAMESPACE/egressnetworkpolicies/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""EgressNetworkPolicy"",
  ""apiVersion"": ""network.openshift.io/v1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X PUT \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/apis/network.openshift.io/v1/namespaces/$NAMESPACE/egressnetworkpolicies/$NAME <<'EOF'
{
  ""kind"": ""EgressNetworkPolicy"",
  ""apiVersion"": ""network.openshift.io/v1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.EgressNetworkPolicy
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the EgressNetworkPolicy
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.EgressNetworkPolicy
|201 Created|v1.EgressNetworkPolicy
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Patch-apis-network.openshift.io-v1-namespaces-namespace-egressnetworkpolicies-name]]
=== Patch a EgressNetworkPolicy in a namespace
Partially update the specified EgressNetworkPolicy

==== HTTP request
----
PATCH /apis/network.openshift.io/v1/namespaces/$NAMESPACE/egressnetworkpolicies/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json-patch+json'

{
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X PATCH \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json-patch+json' \\
    https://$ENDPOINT/apis/network.openshift.io/v1/namespaces/$NAMESPACE/egressnetworkpolicies/$NAME <<'EOF'
{
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.Patch
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the EgressNetworkPolicy
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.EgressNetworkPolicy
|401 Unauthorized|
|===

==== Consumes

* application/json-patch+json
* application/merge-patch+json
* application/strategic-merge-patch+json

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Delete-apis-network.openshift.io-v1-namespaces-namespace-egressnetworkpolicies-name]]
=== Delete a EgressNetworkPolicy in a namespace
Delete an EgressNetworkPolicy

==== HTTP request
----
DELETE /apis/network.openshift.io/v1/namespaces/$NAMESPACE/egressnetworkpolicies/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X DELETE \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/apis/network.openshift.io/v1/namespaces/$NAMESPACE/egressnetworkpolicies/$NAME <<'EOF'
{
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.DeleteOptions
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the EgressNetworkPolicy
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|gracePeriodSeconds|The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
|orphanDependents|Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the ""orphan"" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
|propagationPolicy|Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.Status
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Delete-apis-network.openshift.io-v1-namespaces-namespace-egressnetworkpolicies]]
=== Delete all EgressNetworkPolicies in a namespace
Delete collection of EgressNetworkPolicy

==== HTTP request
----
DELETE /apis/network.openshift.io/v1/namespaces/$NAMESPACE/egressnetworkpolicies HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -X DELETE \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/network.openshift.io/v1/namespaces/$NAMESPACE/egressnetworkpolicies
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.Status
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf



",12205,False,2446.783387396256,median
"= Microsoft Dynamics CRM Connector Reference
:page-aliases: connectors::ms-dynamics/ms-dynamics-crm-connector-reference.adoc

Support Category: https://www.mulesoft.com/legal/versioning-back-support-policy#anypoint-connectors[Select]

Microsoft Dynamics CRM Connector Version 3.2

Release Notes: xref:release-notes::connector/ms-dynamics-crm-connector-release-notes-mule-4.adoc[Microsoft Dynamics CRM Connector Release Notes]


[[dynamics-crm-config]]
== Dynamics CRM Configurations


==== Parameters
[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
|Name | String | The name for this configuration. Connectors reference the configuration with this name. | | x
| Connection a| * <<dynamics-crm-config_claims, Claims>>
* <<dynamics-crm-config_kerberos, Kerberos>>
* <<dynamics-crm-config_ntlm, Ntlm>>
* <<dynamics-crm-config_online, Online>>
 | The connection types to provide to this configuration. | | x
| Expiration Policy a| <<ExpirationPolicy>> |  Configures the minimum amount of time that a dynamic configuration instance can remain idle before Mule considers it eligible for expiration. This does not mean that the instance expires at the exact moment that it becomes eligible. Mule purges the instances as appropriate. |  |
|===

== Connection Types

[[dynamics-crm-config_claims]]
=== Claims

This authentication method includes directory sources that contain additional information (claims) about users to verify their identity. 

[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Username a| String |  Username to connect to Dynamics CRM. |  | x
| Password a| String |  Microsoft Windows password to connect to Dynamics NAV. |  | x
| Organization Service Url a| String |  Base URL where the SOAP services are exposed in the form `+https://<Server>:<WebServicePort>/<ServerInstance>/WS+`, for example: `+https://hostname:7047/DynamicsNAV90/WS+` |  | x
| Disable Cn Check a| Boolean |  Disable SSL certificate validation. |  false |
| Read Timeout a| Number |  Specifies the amount of time in milliseconds that the consumer waits for a response before it times out. Default value is 0, which means infinite. |  0 |
| Connection Timeout a| Number |  Specifies the amount of time in milliseconds that the consumer attempts to establish a connection before it times out. Default value is 0, which means infinite. |  0 |
| Enable Logging a| Boolean |  If this is `true`, requests and responses display in console log. |  `false` |
| Host a| String |  Hostname of the proxy. If this property is not set, then no proxy is used, otherwise a proxy is used, but a proxy host must be specified. |  |
| Port a| Number |  Port of the proxy. If host is set, then this property must be set and cannot be a negative number. |  |
| Username a| String |  Username used to authenticate against the proxy. If this property is not set, then no authentication is going to be uses for the proxy, otherwise this value must be specified. |  |
| Password a| String |  Password used to authenticate against the proxy. |  |
| Reconnection a| <<Reconnection>> |  When the application is deployed, a connectivity test is performed on all connectors. If set to `true`, deployment fails if the test doesn't pass after exhausting the associated reconnection strategy. |  |
| Pooling Profile a| <<PoolingProfile>> |  Characteristics of the connection pool. |  |
|===

[[dynamics-crm-config_kerberos]]
=== Kerberos

Clients obtain tickets from the Kerberos Key Distribution Center (KDC) and present the tickets to the server when the connection is established. 

[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Username a| String |  Username that you want to login with. Domain should not be included. |  | x
| Password a| String |  Password for the user that you are going to login. |  | x
| Organization Service Url a| String |  URL for the SharePoint instance that the connector is going to interact with. |  | x
| SPN a| String |  Service Principal Names (SPN) for the SharePoint web service. |  |
| Realm a| String |  The case-sensitive default realm (domain name) that the user belongs to. |  |
| KDC a| String |  The Key Distribution Center (KDC), usually the domain controller name, to authenticate the user. |  |
| Login Properties File Path a| String |  Path to a customized login properties file. When not specified, default values which usually work for most cases are set up. |  |
| Kerberos Properties File Path a| String |  Path to a customized Kerberos properties file. |  |
| Disable SSL certificate validation a| Boolean |  When dealing with HTTPS certificates, if the certificate is not signed by a trusted partner, the server might respond with an exception.  To prevent this, you can disable the Common Name (CN) check.  *Note:* This is not recommended for production environments. |  `false` |
| Host a| String |  Hostname of the proxy. If this property is not set, then no proxy is used, otherwise a proxy is used, but a proxy host must be specified. |  |
| Port a| Number |  Port of the proxy. If a *Host* value is set, then this property must be set and cannot be a negative number. |  |
| Username a| String |  Username used to authenticate against the proxy. If this property is not set, then no authentication is used with the proxy, otherwise this value must be specified. |  |
| Password a| String |  Password used to authenticate against the proxy. |  |
| Read Timeout a| Number |  Specifies the amount of time in milliseconds that the consumer waits for a response before it times out. Default value is 0, which means infinite. |  0 |
| Connection Timeout a| Number |  Specifies the amount of time in milliseconds that the consumer attempts to establish a connection before it times out. Default value is 0, which means infinite. |  0 |
| Enable Logging a| Boolean |  If this is `true`, requests and responses display in the console log. |  `false` |
| Reconnection a| <<Reconnection>> |  When the application is deployed, a connectivity test is performed on all connectors. If set to `true`, deployment fails if the test doesn't pass after exhausting the associated reconnection strategy. |  |
| Pooling Profile a| <<PoolingProfile>> |  Characteristics of the connection pool |  |
|===

[[dynamics-crm-config_ntlm]]
=== NTLM

This authentication type is used on networks that include systems running on both Windows and stand-alone systems and uses an encrypted challenge-response protocol to authenticate the user.

[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Username a| String |  Username to connect to Dynamics CRM. |  | x
| Password a| String |  The Windows password to connect to Dynamics NAV. |  | x
| Organization Service Url a| String |  Base URL where the SOAP services are exposed in the form `+https://<Server>:<WebServicePort>/<ServerInstance>/WS+`. Example: `+https://hostname:7047/DynamicsNAV90/WS+` |  | x
| Disable Cn Check a| Boolean |  Disable SSL certificate validation. |  `false` |
| Gateway Router Service Address a| String |  Gateway router service address. |  |
| Read Timeout a| Number |  Specifies the amount of time in milliseconds that the consumer waits for a response before it times out. Default value is 0, which means infinite. |  0 |
| Connection Timeout a| Number |  Specifies the amount of time in milliseconds that the consumer attempts to establish a connection before it times out. Default value is 0, which means infinite. |  0 |
| Enable Logging a| Boolean |  If this is true, requests and responses display in the console log. |  false |
| Host a| String |  Hostname of the proxy. If this property is not set, then no proxy is used, otherwise a proxy is used, but a proxy host must be specified. |  |
| Port a| Number |  Port of the proxy. If a *Host* value is set, then this property must be set and cannot be a negative number. |  |
| Username a| String |  Username used to authenticate against the proxy. If this property is not set, then no authentication is going to use against the proxy, otherwise this value must be specified. |  |
| Password a| String |  Password used to authenticate against the proxy. |  |
| Reconnection a| <<Reconnection>> |  When the application is deployed, a connectivity test is performed on all connectors. If set to `true`, deployment fails if the test doesn't pass after exhausting the associated reconnection strategy. |  |
| Pooling Profile a| <<PoolingProfile>> |  Characteristics of the connection pool. |  |
|===

[[dynamics-crm-config_online]]
=== Online


[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Username a| String |  Username to connect to Dynamics CRM |  | x
| Password a| String |  Windows password to connect to Dynamics NAV |  | x
| Organization Service Url a| String |  Base URL where the SOAP services are exposed in the form `+https://<Server>:<WebServicePort>/<ServerInstance>/WS+`. Example: `+https://hostname:7047/DynamicsNAV90/WS+` |  | x
| Disable Cn Check a| Boolean |  Disable SSL certificate validation. |  `false` |
| Authentication Retries a| Number |  If the authentication process to Microsoft fails the first time, the connector attempts to re-authenticate this many times. |  | x
| Read Timeout a| Number |  Specifies the amount of time in milliseconds that the consumer waits for a response before it times out. Default value is 0, which means infinite. |  0 |
| Connection Timeout a| Number |  Specifies the amount of time in milliseconds that the consumer attempts to establish a connection before it times out. Default value is 0, which means infinite. |  0 |
| Enable Logging a| Boolean |  If this is `true`, requests and responses display in the console log. |  false |
| Host a| String |  Hostname of the proxy. If this property is not set, then no proxy is used, otherwise a proxy is used, but a proxy host must be specified. |  |
| Port a| Number |  Port of the proxy. If a *Host* value is set, this property must be set and cannot be a negative number. |  |
| Username a| String |  Username used to authenticate against the proxy. If this property is not set, then no authentication is going to use against the proxy, otherwise this value must be specified. |  |
| Password a| String |  Password used to authenticate against the proxy. |  |
| Sts Metadata Url a| String |  The security token service's metadata exchange URL. For Active Directory federation services (ADFS), this is usually `+https://mycompany-sts.com/adfs/services/trust/mex+`. |  |
| Sts Username Port Qname a| String |  The name of port that accepts username and password credentials as described in the STS's metadata exchange URL. This value has to be specified as a QName in the format `+{http://schemas.microsoft.com/ws/2008/06/identity/securitytokenservice}UserNameWSTrustBinding_IWSTrust13Async+`. |  |
| Reconnection a| <<Reconnection>> |  When the application is deployed, a connectivity test is performed on all connectors. If set to `true`, deployment fails if the test doesn't pass after exhausting the associated reconnection strategy. |  |
| Pooling Profile a| <<PoolingProfile>> |  Characteristics of the connection pool |  |
|===

== Sources

* <<deleted-object>>
* <<modified-object>>
* <<new-object>>

[NOTE]
Microsoft Dynamics CRM Connector sources (listeners) use Object Store to save watermarks. You might experience limitations that are specific to the Object Store implementation you are using (Object Store for CloudHub deployments or Object Store for on-premises deployments), so configure Object Store to suit your needs. +
For more information, see https://help.mulesoft.com/s/article/The-Different-Types-of-Object-Stores-Explained[The Different Types of Object Stores Explained].

[[deleted-object]]
=== Deleted Object

`<microsoft-dynamics-crm:deleted-object>`


==== Parameters
[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Since a| String |  Required date format is `'yyyy-MM-dd'T'HH:mm:ss'Z'` |  |
| Field Type a| String |  |  | x
| Primary Node Only a| Boolean |  Whether this source should only be executed on the primary node when running in a cluster. |  |
| Scheduling Strategy a| scheduling-strategy |  Configures the scheduler that triggers the polling |  | x
| Redelivery Policy a| <<RedeliveryPolicy>> |  Defines a policy for processing the redelivery of the same message |  |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Object
| Attributes Type a| Any
|===

=== For Configurations
* <<dynamics-crm-config>>



[[modified-object]]
=== Modified Object
`<microsoft-dynamics-crm:modified-object>`


==== Parameters
[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Since a| String |  Required date format is `'yyyy-MM-dd'T'HH:mm:ss'Z'` |  |
| Field Type a| String |  |  | x
| Primary Node Only a| Boolean |  Whether this source should only be executed on the primary node when running in a cluster. |  |
| Scheduling Strategy a| scheduling-strategy |  Configures the scheduler that triggers the polling |  | x
| Redelivery Policy a| <<RedeliveryPolicy>> |  Defines a policy for processing the redelivery of the same message |  |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Object
| Attributes Type a| Any
|===

=== For Configurations
* <<dynamics-crm-config>>



[[new-object]]
=== New Object
`<microsoft-dynamics-crm:new-object>`


==== Parameters
[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Since a| String |  Required date format is `'yyyy-MM-dd'T'HH:mm:ss'Z'` |  |
| Field Type a| String |  |  | x
| Primary Node Only a| Boolean |  Whether this source should only be executed on the primary node when running in a cluster. |  |
| Scheduling Strategy a| scheduling-strategy |  Configures the scheduler that triggers the polling. |  | x
| Redelivery Policy a| <<RedeliveryPolicy>> |  Defines a policy for processing the redelivery of the same message. |  |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Object
| Attributes Type a| Any
|===

=== For Configurations
* <<dynamics-crm-config>>


== Operations

Supported operations:

* <<associate>>
* <<create>>
* <<createMultiple>>
* <<delete>>
* <<deleteMultiple>>
* <<disassociate>>
* <<execute>>
* <<executeMultiple>>
* <<retrieve>>
* <<retrieveMultipleByQuery>>
* <<update>>
* <<updateMultiple>>




[[associate]]
=== Associate
`<microsoft-dynamics-crm:associate>`

Create links between records.

==== Parameters

[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Logical Name a| String |  The logical name of the entity. |  | x
| Id a| String |  The ID of the record to which the related records are associated. |  | x
| Relationship Entity Role Is Referenced a| Boolean |

* `false`: When the primary entity record is referencing the record to associate.
* `true`: When the primary entity record is referenced by the record to associate. |  false |
| Relationship Schema Name a| String |  The name of the relationship to create the link. |  | x
| Related Entities IDs a| Array of String |  A List<String> with the related entity records IDs to associate. |  | x
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===


=== For Configurations

* <<dynamics-crm-config>>

==== Throws

* MICROSOFT-DYNAMICS-CRM:CONNECTIVITY
* MICROSOFT-DYNAMICS-CRM:INCOMPLETE_WSDL
* MICROSOFT-DYNAMICS-CRM:INVALID_CERTIFICATE
* MICROSOFT-DYNAMICS-CRM:INVALID_CREDENTIALS
* MICROSOFT-DYNAMICS-CRM:INVALID_CRYPTOGRAPHIC_ALGORITHM
* MICROSOFT-DYNAMICS-CRM:INVALID_JDK_VERSION
* MICROSOFT-DYNAMICS-CRM:INVALID_SESSION
* MICROSOFT-DYNAMICS-CRM:INVALID_URL
* MICROSOFT-DYNAMICS-CRM:RETRY_EXHAUSTED
* MICROSOFT-DYNAMICS-CRM:TRANSACTION
* MICROSOFT-DYNAMICS-CRM:TRANSFORMATION
* MICROSOFT-DYNAMICS-CRM:UNKNOWN
* MICROSOFT-DYNAMICS-CRM:VALIDATION


[[create]]
=== Create
`<microsoft-dynamics-crm:create>`

Create a new record.

==== Parameters

[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Logical Name a| String |  The logical name of the entity. |  | x
| Attributes a| Object |  The attributes of the record as a `Map<String, Object>`. |  `#[payload]` |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |String
|===

=== For Configurations
* <<dynamics-crm-config>>

==== Throws

* MICROSOFT-DYNAMICS-CRM:CONNECTIVITY
* MICROSOFT-DYNAMICS-CRM:INCOMPLETE_WSDL
* MICROSOFT-DYNAMICS-CRM:INVALID_CERTIFICATE
* MICROSOFT-DYNAMICS-CRM:INVALID_CREDENTIALS
* MICROSOFT-DYNAMICS-CRM:INVALID_CRYPTOGRAPHIC_ALGORITHM
* MICROSOFT-DYNAMICS-CRM:INVALID_JDK_VERSION
* MICROSOFT-DYNAMICS-CRM:INVALID_SESSION
* MICROSOFT-DYNAMICS-CRM:INVALID_URL
* MICROSOFT-DYNAMICS-CRM:RETRY_EXHAUSTED
* MICROSOFT-DYNAMICS-CRM:TRANSACTION
* MICROSOFT-DYNAMICS-CRM:TRANSFORMATION
* MICROSOFT-DYNAMICS-CRM:UNKNOWN
* MICROSOFT-DYNAMICS-CRM:VALIDATION


[[createMultiple]]
=== Create Multiple
`<microsoft-dynamics-crm:create-multiple>`

Create multiple new records.

==== Parameters

[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Logical Name a| String |  The logical name of the entity. |  | x
| List Of Attributes a| Array of Object |  The list of attributes of the record as a `List<Map<String, Object>>`. |  `#[payload]` |
| Use Single Transaction a| Boolean |  If supported (CRM 2016 and above), use a single transaction to create all items, if anyone fails then rollback all. |  false |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |<<BulkOperationResult>>
|===

=== For Configurations
* <<dynamics-crm-config>>

==== Throws
* MICROSOFT-DYNAMICS-CRM:CONNECTIVITY
* MICROSOFT-DYNAMICS-CRM:INCOMPLETE_WSDL
* MICROSOFT-DYNAMICS-CRM:INVALID_CERTIFICATE
* MICROSOFT-DYNAMICS-CRM:INVALID_CREDENTIALS
* MICROSOFT-DYNAMICS-CRM:INVALID_CRYPTOGRAPHIC_ALGORITHM
* MICROSOFT-DYNAMICS-CRM:INVALID_JDK_VERSION
* MICROSOFT-DYNAMICS-CRM:INVALID_SESSION
* MICROSOFT-DYNAMICS-CRM:INVALID_URL
* MICROSOFT-DYNAMICS-CRM:RETRY_EXHAUSTED
* MICROSOFT-DYNAMICS-CRM:TRANSACTION
* MICROSOFT-DYNAMICS-CRM:TRANSFORMATION
* MICROSOFT-DYNAMICS-CRM:UNKNOWN
* MICROSOFT-DYNAMICS-CRM:VALIDATION


[[delete]]
=== Delete
`<microsoft-dynamics-crm:delete>`

Delete a record.

==== Parameters
[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Logical Name a| String |  The logical name of the entity. |  | x
| Id a| String |  The ID of the record to delete. |  | x
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===


=== For Configurations
* <<dynamics-crm-config>>

==== Throws
* MICROSOFT-DYNAMICS-CRM:CONNECTIVITY
* MICROSOFT-DYNAMICS-CRM:INCOMPLETE_WSDL
* MICROSOFT-DYNAMICS-CRM:INVALID_CERTIFICATE
* MICROSOFT-DYNAMICS-CRM:INVALID_CREDENTIALS
* MICROSOFT-DYNAMICS-CRM:INVALID_CRYPTOGRAPHIC_ALGORITHM
* MICROSOFT-DYNAMICS-CRM:INVALID_JDK_VERSION
* MICROSOFT-DYNAMICS-CRM:INVALID_SESSION
* MICROSOFT-DYNAMICS-CRM:INVALID_URL
* MICROSOFT-DYNAMICS-CRM:RETRY_EXHAUSTED
* MICROSOFT-DYNAMICS-CRM:TRANSACTION
* MICROSOFT-DYNAMICS-CRM:TRANSFORMATION
* MICROSOFT-DYNAMICS-CRM:UNKNOWN
* MICROSOFT-DYNAMICS-CRM:VALIDATION


[[deleteMultiple]]
=== Delete Multiple
`<microsoft-dynamics-crm:delete-multiple>`

Delete multiple records.

==== Parameters
[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Logical Name a| String |  The logical name of the entity. |  | x
| IDs a| Array of String |  The IDs of the records to delete. |  | x
| Use Single Transaction a| Boolean |  If supported (CRM 2016 and above) use a single transaction to delete all items, if anyone fails then rollback all. |  false |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |<<BulkOperationResult>>
|===

=== For Configurations
* <<dynamics-crm-config>>

==== Throws
* MICROSOFT-DYNAMICS-CRM:CONNECTIVITY
* MICROSOFT-DYNAMICS-CRM:INCOMPLETE_WSDL
* MICROSOFT-DYNAMICS-CRM:INVALID_CERTIFICATE
* MICROSOFT-DYNAMICS-CRM:INVALID_CREDENTIALS
* MICROSOFT-DYNAMICS-CRM:INVALID_CRYPTOGRAPHIC_ALGORITHM
* MICROSOFT-DYNAMICS-CRM:INVALID_JDK_VERSION
* MICROSOFT-DYNAMICS-CRM:INVALID_SESSION
* MICROSOFT-DYNAMICS-CRM:INVALID_URL
* MICROSOFT-DYNAMICS-CRM:RETRY_EXHAUSTED
* MICROSOFT-DYNAMICS-CRM:TRANSACTION
* MICROSOFT-DYNAMICS-CRM:TRANSFORMATION
* MICROSOFT-DYNAMICS-CRM:UNKNOWN
* MICROSOFT-DYNAMICS-CRM:VALIDATION


[[disassociate]]
=== Disassociate
`<microsoft-dynamics-crm:disassociate>`

Delete a link between records.

==== Parameters
[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Logical Name a| String |  The logical name of entity. |  | x
| Id a| String |  The ID of the record from which the related records are disassociated. |  | x
| Relationship Entity Role Is Referenced a| Boolean |  false: when the primary entity record is Referencing the record to associate; true: when the primary entity record is Referenced by the record to associate. |  false |
| Relationship Schema Name a| String |  The name of the relationship to delete the link. |  | x
| Related Entities IDs a| Array of String |  A List<String> with the related entity records IDs to disassociate. |  | x
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===


=== For Configurations
* <<dynamics-crm-config>>

==== Throws
* MICROSOFT-DYNAMICS-CRM:CONNECTIVITY
* MICROSOFT-DYNAMICS-CRM:INCOMPLETE_WSDL
* MICROSOFT-DYNAMICS-CRM:INVALID_CERTIFICATE
* MICROSOFT-DYNAMICS-CRM:INVALID_CREDENTIALS
* MICROSOFT-DYNAMICS-CRM:INVALID_CRYPTOGRAPHIC_ALGORITHM
* MICROSOFT-DYNAMICS-CRM:INVALID_JDK_VERSION
* MICROSOFT-DYNAMICS-CRM:INVALID_SESSION
* MICROSOFT-DYNAMICS-CRM:INVALID_URL
* MICROSOFT-DYNAMICS-CRM:RETRY_EXHAUSTED
* MICROSOFT-DYNAMICS-CRM:TRANSACTION
* MICROSOFT-DYNAMICS-CRM:TRANSFORMATION
* MICROSOFT-DYNAMICS-CRM:UNKNOWN
* MICROSOFT-DYNAMICS-CRM:VALIDATION


[[execute]]
=== Execute
`<microsoft-dynamics-crm:execute>`

Executes a message in the form of a request, and returns a response.

==== Parameters
[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Request Name a| String |  The logical name of request make. |  | x
| Request Parameters a| Any |  [DEPRECATED] This parameter will be removed from the configuration in the near future. Set the `#[payload]` correctly before calling the connector. |  `#[payload]` |
| Request Id a| String |  The ID of the request to make. |  |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Any
|===

=== For Configurations
* <<dynamics-crm-config>>

==== Throws
* MICROSOFT-DYNAMICS-CRM:CONNECTIVITY
* MICROSOFT-DYNAMICS-CRM:INCOMPLETE_WSDL
* MICROSOFT-DYNAMICS-CRM:INVALID_CERTIFICATE
* MICROSOFT-DYNAMICS-CRM:INVALID_CREDENTIALS
* MICROSOFT-DYNAMICS-CRM:INVALID_CRYPTOGRAPHIC_ALGORITHM
* MICROSOFT-DYNAMICS-CRM:INVALID_JDK_VERSION
* MICROSOFT-DYNAMICS-CRM:INVALID_SESSION
* MICROSOFT-DYNAMICS-CRM:INVALID_URL
* MICROSOFT-DYNAMICS-CRM:RETRY_EXHAUSTED
* MICROSOFT-DYNAMICS-CRM:TRANSACTION
* MICROSOFT-DYNAMICS-CRM:TRANSFORMATION
* MICROSOFT-DYNAMICS-CRM:UNKNOWN
* MICROSOFT-DYNAMICS-CRM:VALIDATION


[[executeMultiple]]
=== Execute Multiple
`<microsoft-dynamics-crm:execute-multiple>`

Executes multiple messages in the form of a request, and returns their respective responses.

==== Parameters
[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Requests a| Array of Any |  This parameter is a list of the requests (`OrganizationRequest` or `Map`). Set the `#[payload]` correctly before calling the connector. |  `#[payload]` |
| Use Single Transaction a| Boolean |  If supported (CRM 2016 and above) use a single transaction to execute all requests, if anyone fails then rollback all. |  false |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |<<BulkOperationResult>>
|===

=== For Configurations
* <<dynamics-crm-config>>

==== Throws
* MICROSOFT-DYNAMICS-CRM:CONNECTIVITY
* MICROSOFT-DYNAMICS-CRM:INCOMPLETE_WSDL
* MICROSOFT-DYNAMICS-CRM:INVALID_CERTIFICATE
* MICROSOFT-DYNAMICS-CRM:INVALID_CREDENTIALS
* MICROSOFT-DYNAMICS-CRM:INVALID_CRYPTOGRAPHIC_ALGORITHM
* MICROSOFT-DYNAMICS-CRM:INVALID_JDK_VERSION
* MICROSOFT-DYNAMICS-CRM:INVALID_SESSION
* MICROSOFT-DYNAMICS-CRM:INVALID_URL
* MICROSOFT-DYNAMICS-CRM:RETRY_EXHAUSTED
* MICROSOFT-DYNAMICS-CRM:TRANSACTION
* MICROSOFT-DYNAMICS-CRM:TRANSFORMATION
* MICROSOFT-DYNAMICS-CRM:UNKNOWN
* MICROSOFT-DYNAMICS-CRM:VALIDATION


[[retrieve]]
=== Retrieve
`<microsoft-dynamics-crm:retrieve>`

Retrieve a record.

==== Parameters
[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Logical Name a| String |  The logical name of the entity. |  | x
| Id a| String |  The ID of the record to retrieve. |  | x
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Object
|===

=== For Configurations
* <<dynamics-crm-config>>

==== Throws
* MICROSOFT-DYNAMICS-CRM:CONNECTIVITY
* MICROSOFT-DYNAMICS-CRM:INCOMPLETE_WSDL
* MICROSOFT-DYNAMICS-CRM:INVALID_CERTIFICATE
* MICROSOFT-DYNAMICS-CRM:INVALID_CREDENTIALS
* MICROSOFT-DYNAMICS-CRM:INVALID_CRYPTOGRAPHIC_ALGORITHM
* MICROSOFT-DYNAMICS-CRM:INVALID_JDK_VERSION
* MICROSOFT-DYNAMICS-CRM:INVALID_SESSION
* MICROSOFT-DYNAMICS-CRM:INVALID_URL
* MICROSOFT-DYNAMICS-CRM:RETRY_EXHAUSTED
* MICROSOFT-DYNAMICS-CRM:TRANSACTION
* MICROSOFT-DYNAMICS-CRM:TRANSFORMATION
* MICROSOFT-DYNAMICS-CRM:UNKNOWN
* MICROSOFT-DYNAMICS-CRM:VALIDATION


[[retrieveMultipleByQuery]]
=== Retrieve Multiple By Query
`<microsoft-dynamics-crm:retrieve-multiple-by-query>`


Use a query to retrieve multiple records.  You can find the definition of the Microsoft XML query language in the schema definition in `+http://msdn.microsoft.com/en-us/library/gg328332.aspx+`.

You can find the aggregation examples here `+http://msdn.microsoft.com/en-us/library/gg328122.aspx+`.


==== Parameters
[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Query a| String |  For DataSense Query Language, the DSQL query. For native query language, the Fetch XML query. |  `#[payload]` |
| Items Per Page a| Number |  The number of items returned per page. |  50 |
| Single Page Number a| Number |  If greater than 0, returns only that specific page. |  -1 |
| Streaming Strategy a| * <<repeatable-in-memory-iterable>>
* <<repeatable-file-store-iterable>>
* non-repeatable-iterable |  Configure to use repeatable streams. |  |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Array of Object
|===

=== For Configurations
* <<dynamics-crm-config>>

==== Throws
* MICROSOFT-DYNAMICS-CRM:CONNECTIVITY
* MICROSOFT-DYNAMICS-CRM:INCOMPLETE_WSDL
* MICROSOFT-DYNAMICS-CRM:INVALID_CERTIFICATE
* MICROSOFT-DYNAMICS-CRM:INVALID_CREDENTIALS
* MICROSOFT-DYNAMICS-CRM:INVALID_CRYPTOGRAPHIC_ALGORITHM
* MICROSOFT-DYNAMICS-CRM:INVALID_JDK_VERSION
* MICROSOFT-DYNAMICS-CRM:INVALID_SESSION
* MICROSOFT-DYNAMICS-CRM:INVALID_URL
* MICROSOFT-DYNAMICS-CRM:TRANSACTION
* MICROSOFT-DYNAMICS-CRM:TRANSFORMATION
* MICROSOFT-DYNAMICS-CRM:UNKNOWN
* MICROSOFT-DYNAMICS-CRM:VALIDATION


[[update]]
=== Update
`<microsoft-dynamics-crm:update>`

Update a record's attributes.

==== Parameters
[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Logical Name a| String |  The logical name of the entity. |  | x
| Id a| String |  The ID of the record to update. |  | x
| Attributes a| Object |  The attributes to update as a `Map<String, Object>`. |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===


=== For Configurations
* <<dynamics-crm-config>>

==== Throws
* MICROSOFT-DYNAMICS-CRM:CONNECTIVITY
* MICROSOFT-DYNAMICS-CRM:INCOMPLETE_WSDL
* MICROSOFT-DYNAMICS-CRM:INVALID_CERTIFICATE
* MICROSOFT-DYNAMICS-CRM:INVALID_CREDENTIALS
* MICROSOFT-DYNAMICS-CRM:INVALID_CRYPTOGRAPHIC_ALGORITHM
* MICROSOFT-DYNAMICS-CRM:INVALID_JDK_VERSION
* MICROSOFT-DYNAMICS-CRM:INVALID_SESSION
* MICROSOFT-DYNAMICS-CRM:INVALID_URL
* MICROSOFT-DYNAMICS-CRM:RETRY_EXHAUSTED
* MICROSOFT-DYNAMICS-CRM:TRANSACTION
* MICROSOFT-DYNAMICS-CRM:TRANSFORMATION
* MICROSOFT-DYNAMICS-CRM:UNKNOWN
* MICROSOFT-DYNAMICS-CRM:VALIDATION


[[updateMultiple]]
=== Update Multiple
`<microsoft-dynamics-crm:update-multiple>`

Update a record's attributes.

==== Parameters
[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Logical Name a| String |  The logical name of the entity. |  | x
| List Of Attributes a| Array of Object |  The list of attributes of the record as a `List<Map<String, Object>>`. |  `#[payload]` |
| Use Single Transaction a| Boolean |  If supported (CRM 2016 and above) use a single transaction to update all items, if anyone fails then rollback all. |  false |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |<<BulkOperationResult>>
|===

=== For Configurations
* <<dynamics-crm-config>>

==== Throws
* MICROSOFT-DYNAMICS-CRM:CONNECTIVITY
* MICROSOFT-DYNAMICS-CRM:INCOMPLETE_WSDL
* MICROSOFT-DYNAMICS-CRM:INVALID_CERTIFICATE
* MICROSOFT-DYNAMICS-CRM:INVALID_CREDENTIALS
* MICROSOFT-DYNAMICS-CRM:INVALID_CRYPTOGRAPHIC_ALGORITHM
* MICROSOFT-DYNAMICS-CRM:INVALID_JDK_VERSION
* MICROSOFT-DYNAMICS-CRM:INVALID_SESSION
* MICROSOFT-DYNAMICS-CRM:INVALID_URL
* MICROSOFT-DYNAMICS-CRM:RETRY_EXHAUSTED
* MICROSOFT-DYNAMICS-CRM:TRANSACTION
* MICROSOFT-DYNAMICS-CRM:TRANSFORMATION
* MICROSOFT-DYNAMICS-CRM:UNKNOWN
* MICROSOFT-DYNAMICS-CRM:VALIDATION



[[deleted-object]]
=== Deleted Object
`<microsoft-dynamics-crm:deleted-object>`

==== Parameters
[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Since a| String |  Required date format is `'yyyy-MM-dd'T'HH:mm:ss'Z'` |  |
| Field Type a| String |  |  | x
| Primary Node Only a| Boolean |  Whether this source should only be executed on the primary node when running in a cluster. |  |
| Scheduling Strategy a| scheduling-strategy |  Configures the scheduler that triggers the polling |  | x
| Redelivery Policy a| <<RedeliveryPolicy>> |  Defines a policy for processing the redelivery of the same message |  |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Object
| Attributes Type a| Any
|===

=== For Configurations
* <<dynamics-crm-config>>

[[modified-object]]
=== Modified Object
`<microsoft-dynamics-crm:modified-object>`

==== Parameters
[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Since a| String |  Required date format is `'yyyy-MM-dd'T'HH:mm:ss'Z'` |  |
| Field Type a| String |  |  | x
| Primary Node Only a| Boolean |  Whether this source should only be executed on the primary node when running in a cluster. |  |
| Scheduling Strategy a| scheduling-strategy |  Configures the scheduler that triggers the polling |  | x
| Redelivery Policy a| <<RedeliveryPolicy>> |  Defines a policy for processing the redelivery of the same message |  |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Object
| Attributes Type a| Any
|===

=== For Configurations
* <<dynamics-crm-config>>

[[new-object]]
=== New Object
`<microsoft-dynamics-crm:new-object>`

==== Parameters
[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | | x
| Since a| String |  Required date format is `'yyyy-MM-dd'T'HH:mm:ss'Z'` |  |
| Field Type a| String |  |  | x
| Primary Node Only a| Boolean |  Whether this source should only be executed on the primary node when running in a cluster. |  |
| Scheduling Strategy a| scheduling-strategy |  Configures the scheduler that triggers the polling. |  | x
| Redelivery Policy a| <<RedeliveryPolicy>> |  Defines a policy for processing the redelivery of the same message. |  |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Object
| Attributes Type a| Any
|===

=== For Configurations
* <<dynamics-crm-config>>

== Types
[[Reconnection]]
=== Reconnection

[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Field | Type | Description | Default Value | Required
| Fails Deployment a| Boolean | When the application is deployed, a connectivity test is performed on all connectors. If set to `true`, deployment fails if the test doesn't pass after exhausting the associated reconnection strategy. |  |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> | The reconnection strategy to use. |  |
|===

[[reconnect]]
=== Reconnect

[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Field | Type | Description | Default Value | Required
| Frequency a| Number | How often to reconnect (in milliseconds). | |
| Count a| Number | The number of reconnection attempts to make. | |
| blocking |Boolean |If false, the reconnection strategy runs in a separate, non-blocking thread. |true |
|===

[[reconnect-forever]]
=== Reconnect Forever

[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Field | Type | Description | Default Value | Required
| Frequency a| Number | How often in milliseconds to reconnect. | |
| blocking |Boolean |If false, the reconnection strategy runs in a separate, non-blocking thread. |true |
|===

[[PoolingProfile]]
=== Pooling Profile

[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Field | Type | Description | Default Value | Required
| Max Active a| Number | Controls the maximum number of Mule components that can be borrowed from a session at one time. When set to a negative value, there is no limit to the number of components that may be active at one time. When maxActive is exceeded, the pool is said to be exhausted. |  |
| Max Idle a| Number | Controls the maximum number of Mule components that can sit idle in the pool at any time. When set to a negative value, there is no limit to the number of Mule components that may be idle at one time. |  |
| Max Wait a| Number | Specifies the number of milliseconds to wait for a pooled component to become available when the pool is exhausted and the exhaustedAction is set to WHEN_EXHAUSTED_WAIT. |  |
| Min Eviction Millis a| Number | Determines the minimum amount of time an object may sit idle in the pool before it is eligible for eviction. When non-positive, no objects will be evicted from the pool due to idle time alone. |  |
| Eviction Check Interval Millis a| Number | Specifies the number of milliseconds between runs of the object evictor. When non-positive, no object evictor is executed. |  |
| Exhausted Action a| Enumeration, one of:

** WHEN_EXHAUSTED_GROW
** WHEN_EXHAUSTED_WAIT
** WHEN_EXHAUSTED_FAIL | Specifies the behavior of the Mule component pool when the pool is exhausted. Possible values are:

* WHEN_EXHAUSTED_FAIL - Throws a NoSuchElementException.
* WHEN_EXHAUSTED_WAIT - Blocks by invoking `Object.wait(long)` until a new or idle object is available.
* WHEN_EXHAUSTED_GROW - Creates a new Mule instance and returns it, essentially making the *Max Active* value meaningless. If a positive *Max Wait* value is supplied, it blocks for at most that many milliseconds, after which a NoSuchElementException is thrown. If `maxThreadWait` is a negative value, it  blocks indefinitely. |  |
| Initialisation Policy a| Enumeration, one of:

** INITIALISE_NONE
** INITIALISE_ONE
** INITIALISE_ALL | Determines how components in a pool should be initialized. The possible values are:

* INITIALISE_NONE - Does not load any components into the pool on startup.
* INITIALISE_ONE - Loads one initial component into the pool on startup.
* INITIALISE_ALL - Loads all components in the pool on startup. |  |
| Disabled a| Boolean | Whether pooling should be disabled. |  |
|===

[[ExpirationPolicy]]
=== Expiration Policy

[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Field | Type | Description | Default Value | Required
| Max Idle Time a| Number | A scalar time value for the maximum amount of time a dynamic configuration instance should be allowed to be idle before it's considered eligible for expiration |  |
| Time Unit a| Enumeration, one of:

** NANOSECONDS
** MICROSECONDS
** MILLISECONDS
** SECONDS
** MINUTES
** HOURS
** DAYS | A time unit that qualifies the maxIdleTime attribute |  |
|===

[[RedeliveryPolicy]]
=== Redelivery Policy

[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Field | Type | Description | Default Value | Required
| Max Redelivery Count a| Number | The maximum number of times a message can be redelivered and processed unsuccessfully before triggering process-failed-message |  |
| Use Secure Hash a| Boolean | Whether to use a secure hash algorithm to identify a redelivered message. |  |
| Message Digest Algorithm a| String | The secure hashing algorithm to use. If not set, the default is SHA-256. |  |
| Id Expression a| String | Defines one or more expressions to use to determine when a message has been redelivered. This property may only be set if *Use Secure Hash* is `false`. |  |
| Object Store a| Object Store | The object store where the redelivery counter for each message is  stored. |  |
|===

[[BulkOperationResult]]
=== Bulk Operation Result

[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Field | Type | Description | Default Value | Required
| Id a| Any |  |  |
| Items a| Array of <<BulkItem>> |  |  |
| Successful a| Boolean |  |  |
|===

[[BulkItem]]
=== Bulk Item

[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Field | Type | Description | Default Value | Required
| Exception a| Any |  |  |
| Id a| Any |  |  |
| Message a| String |  |  |
| Payload a| Object |  |  |
| Status Code a| String |  |  |
| Successful a| Boolean |  |  |
|===

[[repeatable-in-memory-iterable]]
=== Repeatable In Memory Iterable

[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Field | Type | Description | Default Value | Required
| Initial Buffer Size a| Number | The amount of instances to initially keep in memory to consume the stream and provide random access to it. If the stream contains more data than can fit into this buffer, then the buffer expands according to the *Buffer Size Increment* attribute, with an upper limit of *Max Buffer Size*. Default value is 100 instances. |  |
| Buffer Size Increment a| Number | This is by how much the buffer size expands if it exceeds its initial size. Setting a value of zero or lower means that the buffer should not expand, meaning that a STREAM_MAXIMUM_SIZE_EXCEEDED error is raised when the buffer gets full. Default value is 100 instances. |  |
| Max Buffer Size a| Number | The maximum amount of memory to use. If more than that is used then a STREAM_MAXIMUM_SIZE_EXCEEDED error is raised. A value lower than or equal to zero means no limit. |  |
|===

[[repeatable-file-store-iterable]]
=== Repeatable File Store Iterable

[%header,cols=""20s,25a,30a,15a,10a""]
|===
| Field | Type | Description | Default Value | Required
| In Memory Objects a| Number | The maximum amount of instances to keep in memory. If more than that is required, then it starts to buffer the content on disk. |  |
| Buffer Unit a| Enumeration, one of:

** BYTE
** KB
** MB
** GB | The unit in which maxInMemorySize is expressed. |  |
|===

== See Also

https://help.mulesoft.com[MuleSoft Help Center]
",12063,True,2794.384224170353,median
"// Copyright (c) 2009-2019 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <chain.h>
#include <core_io.h>
#include <interfaces/chain.h>
#include <key_io.h>
#include <merkleblock.h>
#include <rpc/util.h>
#include <script/descriptor.h>
#include <script/script.h>
#include <script/standard.h>
#include <sync.h>
#include <util/bip32.h>
#include <util/system.h>
#include <util/time.h>
#include <util/translation.h>
#include <wallet/rpcwallet.h>
#include <wallet/wallet.h>

#include <stdint.h>
#include <tuple>

#include <boost/algorithm/string.hpp>

#include <univalue.h>



std::string static EncodeDumpString(const std::string &str) {
    std::stringstream ret;
    for (const unsigned char c : str) {
        if (c <= 32 || c >= 128 || c == '%') {
            ret << '%' << HexStr(&c, &c + 1);
        } else {
            ret << c;
        }
    }
    return ret.str();
}

static std::string DecodeDumpString(const std::string &str) {
    std::stringstream ret;
    for (unsigned int pos = 0; pos < str.length(); pos++) {
        unsigned char c = str[pos];
        if (c == '%' && pos+2 < str.length()) {
            c = (((str[pos+1]>>6)*9+((str[pos+1]-'0')&15)) << 4) |
                ((str[pos+2]>>6)*9+((str[pos+2]-'0')&15));
            pos += 2;
        }
        ret << c;
    }
    return ret.str();
}

static bool GetWalletAddressesForKey(LegacyScriptPubKeyMan* spk_man, const CWallet* const pwallet, const CKeyID& keyid, std::string& strAddr, std::string& strLabel) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
{
    bool fLabelFound = false;
    CKey key;
    spk_man->GetKey(keyid, key);
    for (const auto& dest : GetAllDestinationsForKey(key.GetPubKey())) {
        const auto* address_book_entry = pwallet->FindAddressBookEntry(dest);
        if (address_book_entry) {
            if (!strAddr.empty()) {
                strAddr += "","";
            }
            strAddr += EncodeDestination(dest);
            strLabel = EncodeDumpString(address_book_entry->GetLabel());
            fLabelFound = true;
        }
    }
    if (!fLabelFound) {
        strAddr = EncodeDestination(GetDestinationForKey(key.GetPubKey(), pwallet->m_default_address_type));
    }
    return fLabelFound;
}

static const int64_t TIMESTAMP_MIN = 0;

static void RescanWallet(CWallet& wallet, const WalletRescanReserver& reserver, int64_t time_begin = TIMESTAMP_MIN, bool update = true)
{
    int64_t scanned_time = wallet.RescanFromTime(time_begin, reserver, update);
    if (wallet.IsAbortingRescan()) {
        throw JSONRPCError(RPC_MISC_ERROR, ""Rescan aborted by user."");
    } else if (scanned_time > time_begin) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan was unable to fully rescan the blockchain. Some transactions may be missing."");
    }
}

UniValue importprivkey(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importprivkey"",
                ""\\nAdds a private key (as returned by dumpprivkey) to your wallet. Requires a new wallet backup.\\n""
                ""Hint: use importmulti to import more than one private key.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported key exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""privkey"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The private key (see dumpprivkey)""},
                    {""label"", RPCArg::Type::STR, /* default */ ""current label if address exists, otherwise \\""\\"""", ""An optional label""},
                    {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Rescan the wallet for transactions""},
                },
                RPCResult{RPCResult::Type::NONE, """", """"},
                RPCExamples{
            ""\\nDump a private key\\n""
            + HelpExampleCli(""dumpprivkey"", ""\\""myaddress\\"""") +
            ""\\nImport the private key with rescan\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"""") +
            ""\\nImport using a label and without rescan\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"" \\""testing\\"" false"") +
            ""\\nImport using default blank label and without rescan\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"" \\""\\"" false"") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""importprivkey"", ""\\""mykey\\"", \\""testing\\"", false"")
                },
            }.Check(request);

    if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Cannot import private keys to a wallet with private keys disabled"");
    }

    EnsureLegacyScriptPubKeyMan(*wallet, true);

    WalletRescanReserver reserver(pwallet);
    bool fRescan = true;
    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        EnsureWalletIsUnlocked(pwallet);

        std::string strSecret = request.params[0].get_str();
        std::string strLabel = """";
        if (!request.params[1].isNull())
            strLabel = request.params[1].get_str();

        // Whether to perform rescan after import
        if (!request.params[2].isNull())
            fRescan = request.params[2].get_bool();

        if (fRescan && pwallet->chain().havePruned()) {
            // Exit early and print an error.
            // If a block is pruned after this check, we will import the key(s),
            // but fail the rescan with a generic error.
            throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan is disabled when blocks are pruned"");
        }

        if (fRescan && !reserver.reserve()) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
        }

        CKey key = DecodeSecret(strSecret);
        if (!key.IsValid()) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid private key encoding"");

        CPubKey pubkey = key.GetPubKey();
        CHECK_NONFATAL(key.VerifyPubKey(pubkey));
        CKeyID vchAddress = pubkey.GetID();
        {
            pwallet->MarkDirty();

            // We don't know which corresponding address will be used;
            // label all new addresses, and label existing addresses if a
            // label was passed.
            for (const auto& dest : GetAllDestinationsForKey(pubkey)) {
                if (!request.params[1].isNull() || !pwallet->FindAddressBookEntry(dest)) {
                    pwallet->SetAddressBook(dest, strLabel, ""receive"");
                }
            }

            // Use timestamp of 1 to scan the whole chain
            if (!pwallet->ImportPrivKeys({{vchAddress, key}}, 1)) {
                throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding key to wallet"");
            }

            // Add the wpkh script for this key if possible
            if (pubkey.IsCompressed()) {
                pwallet->ImportScripts({GetScriptForDestination(WitnessV0KeyHash(vchAddress))}, 0 /* timestamp */);
            }
        }
    }
    if (fRescan) {
        RescanWallet(*pwallet, reserver);
    }

    return NullUniValue;
}

UniValue abortrescan(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""abortrescan"",
                ""\\nStops current wallet rescan triggered by an RPC call, e.g. by an importprivkey call.\\n""
                ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {},
                RPCResult{RPCResult::Type::BOOL, """", ""Whether the abort was successful""},
                RPCExamples{
            ""\\nImport a private key\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"""") +
            ""\\nAbort the running wallet rescan\\n""
            + HelpExampleCli(""abortrescan"", """") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""abortrescan"", """")
                },
            }.Check(request);

    if (!pwallet->IsScanning() || pwallet->IsAbortingRescan()) return false;
    pwallet->AbortRescan();
    return true;
}

UniValue importaddress(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importaddress"",
                ""\\nAdds an address or script (in hex) that can be watched as if it were in your wallet but cannot be used to spend. Requires a new wallet backup.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported address exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\\n""
            ""If you have the full public key, you should call importpubkey instead of this.\\n""
            ""Hint: use importmulti to import more than one address.\\n""
            ""\\nNote: If you import a non-standard raw script in hex form, outputs sending to it will be treated\\n""
            ""as change, and not show up in many RPCs.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""address"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The Bitcoin address (or hex-encoded script)""},
                    {""label"", RPCArg::Type::STR, /* default */ ""\\""\\"""", ""An optional label""},
                    {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Rescan the wallet for transactions""},
                    {""p2sh"", RPCArg::Type::BOOL, /* default */ ""false"", ""Add the P2SH version of the script as well""},
                },
                RPCResult{RPCResult::Type::NONE, """", """"},
                RPCExamples{
            ""\\nImport an address with rescan\\n""
            + HelpExampleCli(""importaddress"", ""\\""myaddress\\"""") +
            ""\\nImport using a label without rescan\\n""
            + HelpExampleCli(""importaddress"", ""\\""myaddress\\"" \\""testing\\"" false"") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""importaddress"", ""\\""myaddress\\"", \\""testing\\"", false"")
                },
            }.Check(request);

    EnsureLegacyScriptPubKeyMan(*pwallet, true);

    std::string strLabel;
    if (!request.params[1].isNull())
        strLabel = request.params[1].get_str();

    // Whether to perform rescan after import
    bool fRescan = true;
    if (!request.params[2].isNull())
        fRescan = request.params[2].get_bool();

    if (fRescan && pwallet->chain().havePruned()) {
        // Exit early and print an error.
        // If a block is pruned after this check, we will import the key(s),
        // but fail the rescan with a generic error.
        throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan is disabled when blocks are pruned"");
    }

    WalletRescanReserver reserver(pwallet);
    if (fRescan && !reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    // Whether to import a p2sh version, too
    bool fP2SH = false;
    if (!request.params[3].isNull())
        fP2SH = request.params[3].get_bool();

    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        CTxDestination dest = DecodeDestination(request.params[0].get_str());
        if (IsValidDestination(dest)) {
            if (fP2SH) {
                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Cannot use the p2sh flag with an address - use a script instead"");
            }

            pwallet->MarkDirty();

            pwallet->ImportScriptPubKeys(strLabel, {GetScriptForDestination(dest)}, false /* have_solving_data */, true /* apply_label */, 1 /* timestamp */);
        } else if (IsHex(request.params[0].get_str())) {
            std::vector<unsigned char> data(ParseHex(request.params[0].get_str()));
            CScript redeem_script(data.begin(), data.end());

            std::set<CScript> scripts = {redeem_script};
            pwallet->ImportScripts(scripts, 0 /* timestamp */);

            if (fP2SH) {
                scripts.insert(GetScriptForDestination(ScriptHash(CScriptID(redeem_script))));
            }

            pwallet->ImportScriptPubKeys(strLabel, scripts, false /* have_solving_data */, true /* apply_label */, 1 /* timestamp */);
        } else {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid Vertcoin 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 bitcoin address for the private key""},
                },
                RPCResult{
                    RPCResult::Type::STR, ""key"", ""The private key""
                },
                RPCExamples{
                    HelpExampleCli(""dumpprivkey"", ""\\""myaddress\\"""")
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"""")
            + HelpExampleRpc(""dumpprivkey"", ""\\""myaddress\\"""")
                },
            }.Check(request);

    LegacyScriptPubKeyMan& spk_man = EnsureLegacyScriptPubKeyMan(*wallet);

    auto locked_chain = pwallet->chain().lock();
    LOCK2(pwallet->cs_wallet, spk_man.cs_KeyStore);

    EnsureWalletIsUnlocked(pwallet);

    std::string strAddress = request.params[0].get_str();
    CTxDestination dest = DecodeDestination(strAddress);
    if (!IsValidDestination(dest)) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid Vertcoin address"");
    }
    auto keyid = GetKeyForDestination(spk_man, dest);
    if (keyid.IsNull()) {
        throw JSONRPCError(RPC_TYPE_ERROR, ""Address does not refer to a key"");
    }
    CKey vchSecret;
    if (!spk_man.GetKey(keyid, vchSecret)) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Private key for address "" + strAddress + "" is not known"");
    }
    return EncodeSecret(vchSecret);
}


UniValue dumpwallet(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    const CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""dumpwallet"",
                ""\\nDumps all wallet keys in a human-readable format to a server-side file. This does not allow overwriting existing files.\\n""
                ""Imported scripts are included in the dumpfile, but corresponding BIP173 addresses, etc. may not be added automatically by importwallet.\\n""
                ""Note that if your wallet contains keys which are not derived from your HD seed (e.g. imported keys), these are not covered by\\n""
                ""only backing up the seed itself, and must be backed up too (e.g. ensure you back up the whole dumpfile).\\n"",
                {
                    {""filename"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The filename with path (either absolute or relative to bitcoind)""},
                },
                RPCResult{
                    RPCResult::Type::OBJ, """", """",
                    {
                        {RPCResult::Type::STR, ""filename"", ""The filename with full absolute path""},
                    }
                },
                RPCExamples{
                    HelpExampleCli(""dumpwallet"", ""\\""test\\"""")
            + HelpExampleRpc(""dumpwallet"", ""\\""test\\"""")
                },
            }.Check(request);

    LegacyScriptPubKeyMan& spk_man = EnsureLegacyScriptPubKeyMan(*wallet);

    auto locked_chain = pwallet->chain().lock();
    LOCK2(pwallet->cs_wallet, spk_man.cs_KeyStore);

    EnsureWalletIsUnlocked(pwallet);

    fs::path filepath = request.params[0].get_str();
    filepath = fs::absolute(filepath);

    /* Prevent arbitrary files from being overwritten. There have been reports
     * that users have overwritten wallet files this way:
     * https://github.com/bitcoin/bitcoin/issues/9934
     * It may also avoid other security issues.
     */
    if (fs::exists(filepath)) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, filepath.string() + "" already exists. If you are sure this is what you want, move it out of the way first"");
    }

    fsbridge::ofstream file;
    file.open(filepath);
    if (!file.is_open())
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Cannot open wallet dump file"");

    std::map<CKeyID, int64_t> mapKeyBirth;
    const std::map<CKeyID, int64_t>& mapKeyPool = spk_man.GetAllReserveKeys();
    pwallet->GetKeyBirthTimes(*locked_chain, mapKeyBirth);

    std::set<CScriptID> scripts = spk_man.GetCScripts();

    // sort time/key pairs
    std::vector<std::pair<int64_t, CKeyID> > vKeyBirth;
    for (const auto& entry : mapKeyBirth) {
        vKeyBirth.push_back(std::make_pair(entry.second, entry.first));
    }
    mapKeyBirth.clear();
    std::sort(vKeyBirth.begin(), vKeyBirth.end());

    // produce output
    file << strprintf(""# Wallet dump created by Vertcoin %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 vertcoind 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;
}
",16255,True,3153.3759379335993,median
"// Copyright 2014 Toggl Desktop developers.

#include <vector>

#include ""gtest/gtest.h""

#include ""toggl_api_test.h""
#include ""./../https_client.h""
#include ""./../obm_action.h""
#include ""./../proxy.h""
#include ""./../settings.h""
#include ""./../time_entry.h""
#include ""./../toggl_api.h""
#include ""./../toggl_api_private.h""
#include ""./test_data.h""

#include <iostream>   // NOLINT

#include ""Poco/DateTime.h""
#include ""Poco/File.h""
#include ""Poco/FileStream.h""
#include ""Poco/LocalDateTime.h""
#include ""Poco/Path.h""
#include ""Poco/Runnable.h""
#include ""Poco/Thread.h""

namespace toggl {

namespace testing {

namespace testresult {

// on_url
std::string url("""");

// on_reminder
std::string reminder_title("""");
std::string reminder_informative_text("""");
std::string error("""");

// on_online_state
int64_t online_state(0);

// on_login
uint64_t user_id(0);

// on_display_settings
bool_t open_settings(false);
Settings settings;
bool use_proxy(false);
Proxy proxy;

// on_display_idle_notification
std::string idle_guid("""");
std::string idle_since("""");
std::string idle_duration("""");
uint64_t idle_started(0);
std::string idle_description("""");

// on_display_timer_state
TimeEntry timer_state;

// on_project_autocomplete
std::vector<std::string> projects;

// on_client_select
std::vector<std::string> clients;

// on_time_entry_list
std::vector<TimeEntry> time_entries;

// on_project_colors
std::vector<std::string> project_colors;

// on_obm_experiment
std::vector<ObmExperiment> obm_experiments;

TimeEntry time_entry_by_id(uint64_t id) {
    TimeEntry te;
    std::cerr << ""Looking for "" << id << std::endl;
    for (std::size_t i = 0; i < testing::testresult::time_entries.size();
            i++) {
        std::cerr << ""\\t Checking "" << testing::testresult::time_entries[i].ID() << std::endl;
        if (testing::testresult::time_entries[i].ID() == id) {
            te = testing::testresult::time_entries[i];
            break;
        }
    }
    return te;
}

// on_time_entry_editor
TimeEntry editor_state;
bool_t editor_open(false);
std::string editor_focused_field_name("""");

// toggl_on_help_articles
std::vector<std::string> help_article_names;

bool on_app_open;

int64_t sync_state;

int64_t unsynced_item_count;

std::string update_url;

}  // namespace testresult

void on_app(const bool_t open) {
    testresult::on_app_open = open;
}

void on_sync_state(const int64_t sync_state) {
    testresult::sync_state = sync_state;
}

void on_update(const char_t *url) {
    testresult::update_url = to_string(url);
}

void on_unsynced_items(const int64_t count) {
    testresult::unsynced_item_count = count;
}

void on_error(
    const char_t *errmsg,
    const bool_t user_error) {
    if (errmsg) {
        testresult::error = to_string(errmsg);
        return;
    }
    testresult::error = std::string("""");
}

void on_online_state(const int64_t state) {
    testresult::online_state = state;
}

void on_url(const char_t *url) {
    testresult::url = to_string(url);
}

void on_login(const bool_t open, const uint64_t user_id) {
    testresult::user_id = user_id;
}

void on_reminder(const char_t *title, const char_t *informative_text) {
    testresult::reminder_title = to_string(title);
    testresult::reminder_informative_text = to_string(informative_text);
}

void on_help_articles(TogglHelpArticleView *first) {
    testing::testresult::help_article_names.clear();
    TogglHelpArticleView *it = first;
    while (it) {
        std::string name(to_string(it->Name));
        testing::testresult::help_article_names.push_back(name);
        it = reinterpret_cast<TogglHelpArticleView *>(it->Next);
    }
}

void on_time_entry_list(
    const bool_t open,
    TogglTimeEntryView *first,
    const bool_t show_load_more) {
    testing::testresult::time_entries.clear();
    TogglTimeEntryView *it = first;
    while (it) {
        TimeEntry te;
        te.SetGUID(to_string(it->GUID));
        te.SetID(it->ID);
        te.SetDurationInSeconds(it->DurationInSeconds);
        te.SetDescription(to_string(it->Description));
        te.SetStart(it->Started);
        te.SetStop(it->Ended);
        testing::testresult::time_entries.push_back(te);
        it = reinterpret_cast<TogglTimeEntryView *>(it->Next);
    }
}

void on_time_entry_autocomplete(TogglAutocompleteView *first) {
}

void on_mini_timer_autocomplete(TogglAutocompleteView *first) {
}

void on_project_autocomplete(TogglAutocompleteView *first) {
    testing::testresult::projects.clear();
    TogglAutocompleteView *it = first;
    while (it) {
        testing::testresult::projects.push_back(
            to_string(it->ProjectLabel));
        it = reinterpret_cast<TogglAutocompleteView *>(it->Next);
    }
}

void on_client_select(TogglGenericView *first) {
    testing::testresult::clients.clear();
    TogglGenericView *it = first;
    while (it) {
        testing::testresult::clients.push_back(to_string(it->Name));
        it = reinterpret_cast<TogglGenericView *>(it->Next);
    }
}

void on_workspace_select(TogglGenericView *first) {
}

void on_tags(TogglGenericView *first) {
}

void on_time_entry_editor(
    const bool_t open,
    TogglTimeEntryView *te,
    const char_t *focused_field_name) {
    testing::testresult::editor_state = TimeEntry();
    testing::testresult::editor_state.SetGUID(to_string(te->GUID));
    testing::testresult::editor_open = open;
    testing::testresult::editor_focused_field_name =
        to_string(focused_field_name);
}

void on_display_settings(
    const bool_t open,
    TogglSettingsView *settings) {

    testing::testresult::open_settings = open;

    testing::testresult::settings.use_idle_detection =
        settings->UseIdleDetection;
    testing::testresult::settings.menubar_project = settings->MenubarProject;
    testing::testresult::settings.autodetect_proxy = settings->AutodetectProxy;
    testing::testresult::settings.menubar_timer = settings->MenubarTimer;
    testing::testresult::settings.reminder = settings->Reminder;
    testing::testresult::settings.dock_icon = settings->DockIcon;
    testing::testresult::settings.on_top = settings->OnTop;
    testing::testresult::settings.idle_minutes = settings->IdleMinutes;
    testing::testresult::settings.reminder_minutes = settings->ReminderMinutes;
    testing::testresult::settings.focus_on_shortcut = settings->FocusOnShortcut;
    testing::testresult::settings.manual_mode = settings->ManualMode;
    testing::testresult::settings.autotrack = settings->Autotrack;

    testing::testresult::use_proxy = settings->UseProxy;

    testing::testresult::proxy.SetHost(to_string(settings->ProxyHost));
    testing::testresult::proxy.SetPort(settings->ProxyPort);
    testing::testresult::proxy.SetUsername(
        to_string(settings->ProxyUsername));
    testing::testresult::proxy.SetPassword(
        to_string(settings->ProxyPassword));

    testing::testresult::settings.remind_starts = to_string(settings->RemindStarts);
    testing::testresult::settings.remind_ends = to_string(settings->RemindEnds);
    testing::testresult::settings.remind_mon = settings->RemindMon;
    testing::testresult::settings.remind_tue = settings->RemindTue;
    testing::testresult::settings.remind_wed = settings->RemindWed;
    testing::testresult::settings.remind_thu = settings->RemindThu;
    testing::testresult::settings.remind_fri = settings->RemindFri;
    testing::testresult::settings.remind_sat = settings->RemindSat;
    testing::testresult::settings.remind_sun = settings->RemindSun;
}

void on_project_colors(
    string_list_t color_list,
    const uint64_t color_count) {
    testresult::project_colors.clear();
    for (uint64_t i = 0; i < color_count; i++) {
        testresult::project_colors.push_back(to_string(color_list[i]));
    }
}

void on_obm_experiment(
    const uint64_t nr,
    const bool_t included,
    const bool_t seen) {
    ObmExperiment experiment;
    experiment.SetNr(nr);
    experiment.SetIncluded(included);
    experiment.SetHasSeen(seen);
    testresult::obm_experiments.push_back(experiment);
}

void on_display_timer_state(TogglTimeEntryView *te) {
    testing::testresult::timer_state = TimeEntry();
    if (te) {
        testing::testresult::timer_state.SetID(te->ID);
        testing::testresult::timer_state.SetStart(te->Started);
        testing::testresult::timer_state.SetGUID(to_string(te->GUID));
        testing::testresult::timer_state.SetDurationInSeconds(
            te->DurationInSeconds);
        testing::testresult::timer_state.SetDescription(to_string(te->Description));
        if (te->Tags) {
            testing::testresult::timer_state.SetTags(to_string(te->Tags));
        }
        testing::testresult::timer_state.SetBillable(te->Billable);
        testing::testresult::timer_state.SetPID(te->PID);
        testing::testresult::timer_state.SetTID(te->TID);
    }
}

void on_display_idle_notification(
    const char_t *guid,
    const char_t *since,
    const char_t *duration,
    const int64_t started,
    const char_t *description) {
    testing::testresult::idle_since = to_string(since);
    testing::testresult::idle_started = started;
    testing::testresult::idle_duration = to_string(duration);
    testing::testresult::idle_guid = to_string(guid);
    testing::testresult::idle_description = to_string(description);
}

class App {
 public:
    App() {
        Poco::File f(""test.db"");
        std::cout << f.path();
        if (f.exists()) {
            f.remove(false);
        }

        toggl_set_log_path(STR(""test.log""));

        ctx_ = toggl_context_init(STR(""tests""), STR(""0.1""));

        poco_assert(toggl_set_db_path(ctx_, STR(""test.db"")));

        Poco::Path path(std::string(SRCDIR) + ""ssl/cacert.pem"");
        toggl_set_cacert_path(ctx_, to_char_t(path.toString()));

        toggl_on_show_app(ctx_, on_app);
        toggl_on_sync_state(ctx_, on_sync_state);
        toggl_on_unsynced_items(ctx_, on_unsynced_items);
        toggl_on_update(ctx_, on_update);
        toggl_on_error(ctx_, on_error);
        toggl_on_online_state(ctx_, on_online_state);
        toggl_on_login(ctx_, on_login);
        toggl_on_url(ctx_, on_url);
        toggl_on_reminder(ctx_, on_reminder);
        toggl_on_time_entry_list(ctx_, on_time_entry_list);
        toggl_on_time_entry_autocomplete(ctx_, on_time_entry_autocomplete);
        toggl_on_mini_timer_autocomplete(ctx_, on_mini_timer_autocomplete);
        toggl_on_project_autocomplete(ctx_, on_project_autocomplete);
        toggl_on_workspace_select(ctx_, on_workspace_select);
        toggl_on_client_select(ctx_, on_client_select);
        toggl_on_tags(ctx_, on_tags);
        toggl_on_time_entry_editor(ctx_, on_time_entry_editor);
        toggl_on_settings(ctx_, on_display_settings);
        toggl_on_timer_state(ctx_, on_display_timer_state);
        toggl_on_idle_notification(ctx_, on_display_idle_notification);
        toggl_on_project_colors(ctx_, on_project_colors);
        toggl_on_help_articles(ctx_, on_help_articles);
        toggl_on_obm_experiment(ctx_, on_obm_experiment);

        poco_assert(!toggl_ui_start(ctx_));
    }
    ~App() {
        toggl_context_clear(ctx_);
        ctx_ = 0;
    }

    void *ctx() {
        return ctx_;
    }

 private:
    void *ctx_;
};

// For testing API concurrently
class ApiClient : public Poco::Runnable {
 public:
    explicit ApiClient(testing::App *app, const std::string name)
        : app_(app)
    , name_(name)
    , finished_(false) {}

    void run() {
        std::cout << ""runnable "" << name_ << "" running"" << std::endl;

        for (int i = 0; i < 100; i++) {
            char_t *guid = toggl_start(app_->ctx(), STR(""test""), STR(""""), 0, 0, 0, 0,
                                       false, 0, 0);
            ASSERT_TRUE(guid);

            ASSERT_TRUE(toggl_stop(app_->ctx(), false));

            toggl_edit(app_->ctx(), guid, true, STR(""""));

            ASSERT_TRUE(toggl_delete_time_entry(app_->ctx(), guid));

            free(guid);
        }
        finished_ = true;
    }

    bool finished() const {
        return finished_;
    }

 private:
    testing::App *app_;
    std::string name_;
    bool finished_;
};

}  // namespace testing

TEST(toggl_api, toggl_context_init) {
    testing::App app;
}

TEST(toggl_api, testing_sleep) {
    time_t start = time(0);
    testing_sleep(1);
    int elapsed_seconds = time(0) - start;
    ASSERT_GE(elapsed_seconds, 1);
    ASSERT_LT(elapsed_seconds, 2);
}

TEST(toggl_api, toggl_add_obm_experiment_nr) {
    testing::App app;

    toggl_add_obm_experiment_nr(123);
    ASSERT_EQ(""tests/0.1-obm-123"", toggl::HTTPClient::Config.UserAgent());

    toggl_add_obm_experiment_nr(456);
    ASSERT_EQ(""tests/0.1-obm-123-obm-456"", toggl::HTTPClient::Config.UserAgent());
}

TEST(toggl_api, toggl_set_settings) {
    testing::App app;

    // set to false/null

    ASSERT_TRUE(toggl_set_settings_menubar_project(app.ctx(), false));
    ASSERT_FALSE(testing::testresult::settings.menubar_project);

    ASSERT_TRUE(toggl_set_settings_autodetect_proxy(app.ctx(), false));
    ASSERT_FALSE(testing::testresult::settings.autodetect_proxy);

    ASSERT_TRUE(toggl_set_settings_use_idle_detection(app.ctx(), false));
    ASSERT_FALSE(testing::testresult::settings.use_idle_detection);

    ASSERT_TRUE(toggl_set_settings_menubar_timer(app.ctx(), false));
    ASSERT_FALSE(testing::testresult::settings.menubar_timer);

    ASSERT_TRUE(toggl_set_settings_dock_icon(app.ctx(), false));
    ASSERT_FALSE(testing::testresult::settings.dock_icon);

    ASSERT_TRUE(toggl_set_settings_on_top(app.ctx(), false));
    ASSERT_FALSE(testing::testresult::settings.on_top);

    ASSERT_TRUE(toggl_set_settings_reminder(app.ctx(), false));
    ASSERT_FALSE(testing::testresult::settings.reminder);

    ASSERT_TRUE(toggl_set_settings_idle_minutes(app.ctx(), 0));
    ASSERT_EQ(Poco::UInt64(1), testing::testresult::settings.idle_minutes);

    ASSERT_TRUE(toggl_set_settings_reminder_minutes(app.ctx(), 0));
    ASSERT_EQ(Poco::UInt64(1), testing::testresult::settings.reminder_minutes);

    ASSERT_TRUE(toggl_set_settings_focus_on_shortcut(app.ctx(), false));
    ASSERT_FALSE(testing::testresult::settings.focus_on_shortcut);

    ASSERT_TRUE(toggl_set_settings_manual_mode(app.ctx(), false));
    ASSERT_FALSE(testing::testresult::settings.manual_mode);

    // set to true / not null

    ASSERT_TRUE(toggl_set_settings_menubar_project(app.ctx(), true));
    ASSERT_TRUE(testing::testresult::settings.menubar_project);

    ASSERT_TRUE(toggl_set_settings_autodetect_proxy(app.ctx(), true));
    ASSERT_TRUE(testing::testresult::settings.autodetect_proxy);

    ASSERT_TRUE(toggl_set_settings_use_idle_detection(app.ctx(), true));
    ASSERT_TRUE(testing::testresult::settings.use_idle_detection);

    ASSERT_TRUE(toggl_set_settings_menubar_timer(app.ctx(), true));
    ASSERT_TRUE(testing::testresult::settings.menubar_timer);

    ASSERT_TRUE(toggl_set_settings_dock_icon(app.ctx(), true));
    ASSERT_TRUE(testing::testresult::settings.dock_icon);

    ASSERT_TRUE(toggl_set_settings_on_top(app.ctx(), true));
    ASSERT_TRUE(testing::testresult::settings.on_top);

    ASSERT_TRUE(toggl_set_settings_reminder(app.ctx(), true));
    ASSERT_TRUE(testing::testresult::settings.reminder);

    ASSERT_TRUE(toggl_set_settings_idle_minutes(app.ctx(), 123));
    ASSERT_EQ(Poco::UInt64(123), testing::testresult::settings.idle_minutes);

    ASSERT_TRUE(toggl_set_settings_reminder_minutes(app.ctx(), 222));
    ASSERT_EQ(Poco::UInt64(222),
              testing::testresult::settings.reminder_minutes);

    ASSERT_TRUE(toggl_set_settings_focus_on_shortcut(app.ctx(), true));
    ASSERT_TRUE(testing::testresult::settings.focus_on_shortcut);

    ASSERT_TRUE(toggl_set_settings_manual_mode(app.ctx(), true));
    ASSERT_TRUE(testing::testresult::settings.manual_mode);

    testing::testresult::error = noError;
    ASSERT_TRUE(toggl_set_settings_autotrack(app.ctx(), true));
    ASSERT_EQ(noError, testing::testresult::error);
    ASSERT_TRUE(testing::testresult::settings.autotrack);
}

TEST(toggl_api, toggl_set_proxy_settings) {
    testing::App app;

    ASSERT_TRUE(toggl_set_proxy_settings(
        app.ctx(), 1, STR(""localhost""), 8000, STR(""johnsmith""), STR(""secret"")));

    ASSERT_TRUE(testing::testresult::use_proxy);
    ASSERT_EQ(std::string(""localhost""),
              std::string(testing::testresult::proxy.Host()));
    ASSERT_EQ(8000,
              static_cast<int>(testing::testresult::proxy.Port()));
    ASSERT_EQ(std::string(""johnsmith""),
              std::string(testing::testresult::proxy.Username()));
    ASSERT_EQ(std::string(""secret""),
              std::string(testing::testresult::proxy.Password()));
}

TEST(toggl_api, toggl_set_settings_remind_days) {
    testing::App app;

    testing::testresult::error = noError;
    bool_t res = toggl_set_settings_remind_days(
        app.ctx(), true, true, true, true, true, true, true);
    ASSERT_EQ(noError, testing::testresult::error);
    ASSERT_TRUE(res);

    ASSERT_TRUE(testing::testresult::settings.remind_mon);
    ASSERT_TRUE(testing::testresult::settings.remind_tue);
    ASSERT_TRUE(testing::testresult::settings.remind_wed);
    ASSERT_TRUE(testing::testresult::settings.remind_thu);
    ASSERT_TRUE(testing::testresult::settings.remind_fri);
    ASSERT_TRUE(testing::testresult::settings.remind_sat);
    ASSERT_TRUE(testing::testresult::settings.remind_sun);

    ASSERT_TRUE(toggl_set_settings_remind_days(
        app.ctx(), false, false, false, false, false, false, false));

    ASSERT_FALSE(testing::testresult::settings.remind_mon);
    ASSERT_FALSE(testing::testresult::settings.remind_tue);
    ASSERT_FALSE(testing::testresult::settings.remind_wed);
    ASSERT_FALSE(testing::testresult::settings.remind_thu);
    ASSERT_FALSE(testing::testresult::settings.remind_fri);
    ASSERT_FALSE(testing::testresult::settings.remind_sat);
    ASSERT_FALSE(testing::testresult::settings.remind_sun);
}

TEST(toggl_api, toggl_set_settings_remind_times) {
    testing::App app;

    ASSERT_TRUE(toggl_set_settings_remind_times(app.ctx(), STR(""""), STR("""")));

    ASSERT_EQ(std::string(""""), testing::testresult::settings.remind_starts);
    ASSERT_EQ(std::string(""""), testing::testresult::settings.remind_ends);

    ASSERT_TRUE(toggl_set_settings_remind_times(app.ctx(), STR(""09:30""), STR(""17:30"")));

    ASSERT_EQ(std::string(""09:30""),
              testing::testresult::settings.remind_starts);
    ASSERT_EQ(std::string(""17:30""),
              testing::testresult::settings.remind_ends);
}

TEST(toggl_api, toggl_set_window_settings) {
    testing::App app;

    int64_t x(1), y(2), h(3), w(4);
    testing::testresult::error = """";
    if (!toggl_set_window_settings(app.ctx(), x, y, h, w)) {
        ASSERT_EQ(noError, testing::testresult::error);
    }

    int64_t x1(1), y1(2), h1(3), w1(4);
    testing::testresult::error = """";
    if (!toggl_window_settings(app.ctx(), &x1, &y1, &h1, &w1)) {
        ASSERT_EQ(noError, testing::testresult::error);
    }

    ASSERT_EQ(x, x1);
    ASSERT_EQ(y, y1);
    ASSERT_EQ(h, h1);
    ASSERT_EQ(w, w1);
}

TEST(toggl_api, toggl_get_user_fullname) {
    testing::App app;

    auto str = toggl_get_user_fullname(app.ctx());
    ASSERT_EQ("""", to_string(str));
    free(str);

    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    str = toggl_get_user_fullname(app.ctx());
    ASSERT_EQ(""John Smith"", to_string(str));
    free(str);
}

TEST(toggl_api, toggl_get_user_email) {
    testing::App app;

    auto str = toggl_get_user_email(app.ctx());
    ASSERT_EQ("""", to_string(str));
    free(str);

    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    str = toggl_get_user_email(app.ctx());
    ASSERT_EQ(""johnsmith@toggl.com"", to_string(str));
    free(str);
}

TEST(toggl_api, toggl_show_app) {
    testing::App app;

    testing::testresult::on_app_open = false;

    toggl_show_app(app.ctx());

    ASSERT_TRUE(testing::testresult::on_app_open);
}

TEST(toggl_api, toggl_set_update_channel) {
    testing::App app;

    std::string default_channel(""stable"");

    // Also check that the API itself thinks the default channel is
    auto str = toggl_get_update_channel(app.ctx());
    ASSERT_TRUE(default_channel == to_string(str)
                || std::string(""beta"") == to_string(str));
    free(str);

    ASSERT_FALSE(toggl_set_update_channel(app.ctx(), STR(""invalid"")));

    // The channel should be the same in the API
    str = toggl_get_update_channel(app.ctx());
    ASSERT_TRUE(default_channel == to_string(str) ||
                ""beta"" == to_string(str));
    free(str);

    ASSERT_TRUE(toggl_set_update_channel(app.ctx(), STR(""beta"")));

    // The channel should have been changed in the API
    str = toggl_get_update_channel(app.ctx());
    ASSERT_EQ(std::string(""beta""), to_string(str));
    free(str);

    ASSERT_TRUE(toggl_set_update_channel(app.ctx(), STR(""dev"")));

    // The channel should have been changed in the API
    str = toggl_get_update_channel(app.ctx());
    ASSERT_EQ(std::string(""dev""), to_string(str));
    free(str);

    ASSERT_TRUE(toggl_set_update_channel(app.ctx(), STR(""stable"")));

    // The channel should have been changed in the API
    str = toggl_get_update_channel(app.ctx());
    ASSERT_EQ(std::string(""stable""), to_string(str));
    free(str);
}

TEST(toggl_api, toggl_set_log_level) {
    toggl_set_log_level(STR(""trace""));
}

TEST(toggl_api, toggl_format_tracking_time_duration) {
    auto str = toggl_format_tracking_time_duration(10);
    ASSERT_EQ(""10 sec"", to_string(str));
    free(str);

    str = toggl_format_tracking_time_duration(60);
    ASSERT_EQ(""01:00 min"", to_string(str));
    free(str);

    str = toggl_format_tracking_time_duration(65);
    ASSERT_EQ(""01:05 min"", to_string(str));
    free(str);

    str = toggl_format_tracking_time_duration(3600);
    ASSERT_EQ(""01:00:00"", to_string(str));
    free(str);

    str = toggl_format_tracking_time_duration(5400);
    ASSERT_EQ(""01:30:00"", to_string(str));
    free(str);

    str = toggl_format_tracking_time_duration(5410);
    ASSERT_EQ(""01:30:10"", to_string(str));
    free(str);
}

TEST(toggl_api, toggl_format_tracked_time_duration) {
    auto str  = toggl_format_tracked_time_duration(10);
    ASSERT_EQ(""0:00"", to_string(str));
    free(str);

    str = toggl_format_tracked_time_duration(60);
    ASSERT_EQ(""0:01"", to_string(str));
    free(str);

    str = toggl_format_tracked_time_duration(65);
    ASSERT_EQ(""0:01"", to_string(str));
    free(str);

    str = toggl_format_tracked_time_duration(3600);
    ASSERT_EQ(""1:00"", to_string(str));
    free(str);

    str = toggl_format_tracked_time_duration(5400);
    ASSERT_EQ(""1:30"", to_string(str));
    free(str);

    str = toggl_format_tracked_time_duration(5410);
    ASSERT_EQ(""1:30"", to_string(str));
    free(str);
}

TEST(toggl_api, toggl_password_forgot) {
    testing::App app;
    toggl_password_forgot(app.ctx());
    ASSERT_EQ(""https://toggl.com/forgot-password?desktop=true"",
              testing::testresult::url);
}

TEST(toggl_api, toggl_set_environment) {
    testing::App app;

    toggl_set_environment(app.ctx(), STR(""test""));

    auto env = toggl_environment(app.ctx());
    std::string res(to_string(env));
    free(env);
    ASSERT_EQ(""test"", res);
}

TEST(toggl_api, toggl_set_update_path) {
    testing::App app;

    toggl_set_update_path(app.ctx(), STR(""/tmp/""));

    auto s = toggl_update_path(app.ctx());
    std::string path(to_string(s));
    free(s);

    ASSERT_EQ(""/tmp/"", path);
}

TEST(toggl_api, testing_set_logged_in_user) {
    std::string json = loadTestData();
    testing::App app;
    testing::testresult::error = """";
    bool_t res = testing_set_logged_in_user(app.ctx(), json.c_str());
    ASSERT_EQ(noError, testing::testresult::error);
    ASSERT_TRUE(res);
    ASSERT_EQ(uint64_t(10471231), testing::testresult::user_id);
}

TEST(toggl_api, toggl_disable_update_check) {
    testing::App app;
    toggl_disable_update_check(app.ctx());
}

TEST(toggl_api, toggl_logout) {
    std::string json = loadTestData();
    testing::App app;
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));
    ASSERT_EQ(uint64_t(10471231), testing::testresult::user_id);
    ASSERT_TRUE(toggl_logout(app.ctx()));
    ASSERT_EQ(uint64_t(0), testing::testresult::user_id);
}

TEST(toggl_api, toggl_clear_cache) {
    std::string json = loadTestData();
    testing::App app;
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));
    ASSERT_EQ(uint64_t(10471231), testing::testresult::user_id);
    ASSERT_TRUE(toggl_clear_cache(app.ctx()));
    ASSERT_EQ(uint64_t(0), testing::testresult::user_id);
}

TEST(toggl_api, toggl_debug) {
    toggl_set_log_path(STR(""test.log""));
    toggl_debug(STR(""Test 123""));
}

TEST(toggl_api, toggl_set_idle_seconds) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    toggl_set_idle_seconds(app.ctx(), 0);
    ASSERT_EQ("""", testing::testresult::idle_since);
    ASSERT_EQ(uint64_t(0), testing::testresult::idle_started);
    ASSERT_EQ("""", testing::testresult::idle_duration);
    ASSERT_EQ("""", testing::testresult::idle_guid);

    toggl_set_idle_seconds(app.ctx(), (5*60)-1);
    ASSERT_EQ("""", testing::testresult::idle_since);
    ASSERT_EQ(uint64_t(0), testing::testresult::idle_started);
    ASSERT_EQ("""", testing::testresult::idle_duration);
    ASSERT_EQ("""", testing::testresult::idle_guid);

    toggl_set_idle_seconds(app.ctx(), (5*60));
    ASSERT_EQ("""", testing::testresult::idle_since);
    ASSERT_EQ(uint64_t(0), testing::testresult::idle_started);
    ASSERT_EQ("""", testing::testresult::idle_duration);
    ASSERT_EQ("""", testing::testresult::idle_guid);

    toggl_set_idle_seconds(app.ctx(), 0);
    ASSERT_EQ("""", testing::testresult::idle_since);
    ASSERT_EQ(uint64_t(0), testing::testresult::idle_started);
    ASSERT_EQ("""", testing::testresult::idle_duration);
    ASSERT_EQ("""", testing::testresult::idle_guid);

    char_t *guid = toggl_start(app.ctx(), STR(""test""), STR(""""), 0, 0, 0, 0, false, 0, 0);
    ASSERT_TRUE(guid);
    free(guid);

    toggl_set_idle_seconds(app.ctx(), 5*60);
    ASSERT_EQ("""", testing::testresult::idle_since);
    ASSERT_EQ(uint64_t(0), testing::testresult::idle_started);
    ASSERT_EQ("""", testing::testresult::idle_duration);
    ASSERT_EQ("""", testing::testresult::idle_guid);

    toggl_set_idle_seconds(app.ctx(), 0);
    ASSERT_EQ("""", testing::testresult::idle_since);

    ASSERT_TRUE(toggl_set_time_entry_duration(app.ctx(),
                to_char_t(testing::testresult::timer_state.GUID()),
                STR(""301 seconds"")));

    toggl_set_idle_seconds(app.ctx(), 5*60);
    toggl_set_idle_seconds(app.ctx(), 0);
    ASSERT_NE("""", testing::testresult::idle_since);

    ASSERT_NE(std::string::npos,
              testing::testresult::idle_since.find(""You have been idle since""));
    ASSERT_NE(uint64_t(0), testing::testresult::idle_started);
    ASSERT_EQ(""(5 minutes)"", testing::testresult::idle_duration);
    ASSERT_NE("""", testing::testresult::idle_guid);
}

TEST(toggl_api, toggl_open_in_browser) {
    testing::App app;
    toggl_open_in_browser(app.ctx());
}

TEST(toggl_api, toggl_get_support) {
    testing::App app;
    toggl_get_support(app.ctx(), 0);
    ASSERT_EQ(""https://support.toggl.com/toggl-on-my-desktop/"",
              testing::testresult::url);
}

TEST(toggl_api, toggl_login) {
    testing::App app;
    toggl_login(app.ctx(), STR(""username""), STR(""password""));
}

TEST(toggl_api, toggl_google_login) {
    testing::App app;
    toggl_google_login(app.ctx(), STR(""token""));
}

TEST(toggl_api, toggl_sync) {
    testing::App app;
    toggl_sync(app.ctx());
}

TEST(toggl_api, toggl_add_obm_action) {
    testing::App app;

    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    ASSERT_FALSE(toggl_add_obm_action(app.ctx(), 0, STR(""key""), STR(""value"")));
    ASSERT_FALSE(toggl_add_obm_action(app.ctx(), 1, STR(""key""), STR("" "")));
    ASSERT_FALSE(toggl_add_obm_action(app.ctx(), 2, STR("" ""), STR("""")));
    ASSERT_TRUE(toggl_add_obm_action(app.ctx(), 3, STR(""key""), STR(""value"")));
    ASSERT_TRUE(toggl_add_obm_action(app.ctx(), 3, STR(""key""), STR(""value"")));
}

TEST(toggl_api, toggl_add_project) {
    testing::App app;

    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    auto guid = STR(""07fba193-91c4-0ec8-2894-820df0548a8f"");
    uint64_t wid = 0;
    uint64_t cid = 0;
    auto project_name = STR("""");
    bool_t is_private = false;

    testing::testresult::error = """";
    char_t *res = toggl_add_project(app.ctx(),
                                    guid,
                                    wid,
                                    cid,
                                    STR(""""),
                                    project_name,
                                    is_private,
                                    STR(""""));
    ASSERT_EQ(""Please select a workspace"",
              testing::testresult::error);
    ASSERT_FALSE(res);

    wid = 123456789;
    res = toggl_add_project(app.ctx(),
                            guid,
                            wid,
                            cid,
                            STR(""""),
                            project_name,
                            is_private,
                            STR(""#ffffff""));
    ASSERT_EQ(""Project name must not be empty"",
              testing::testresult::error);
    ASSERT_FALSE(res);
    free(res);

    project_name = STR(""A new project"");
    testing::testresult::error = """";
    res = toggl_add_project(app.ctx(),
                            guid,
                            wid,
                            cid,
                            STR(""""),
                            project_name,
                            is_private,
                            0);
    ASSERT_EQ("""", testing::testresult::error);
    ASSERT_TRUE(res);
    free(res);

    // TODO: remove this when we address async issues in tests
    testing_sleep(1);

    bool found(false);
    for (std::size_t i = 0; i < testing::testresult::projects.size(); i++) {
        if (to_string(project_name) == testing::testresult::projects[i]) {
            found = true;
            break;
        }
    }
    ASSERT_TRUE(found);
}


TEST(toggl_api, toggl_create_client) {
    testing::App app;

    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    uint64_t wid = 0;
    auto client_name = STR(""        "");

    testing::testresult::error = """";
    char_t *res = toggl_create_client(app.ctx(),
                                      wid,
                                      client_name);
    ASSERT_EQ(""Please select a workspace"", testing::testresult::error);
    ASSERT_FALSE(res);
    free(res);

    wid = 123456789;
    res = toggl_create_client(app.ctx(),
                              wid,
                              client_name);
    ASSERT_EQ(""Client name must not be empty"",
              testing::testresult::error);
    ASSERT_FALSE(res);
    free(res);

    client_name = STR(""A new client"");
    testing::testresult::error = """";
    res = toggl_create_client(app.ctx(),
                              wid,
                              client_name);
    ASSERT_EQ("""", testing::testresult::error);
    ASSERT_TRUE(res);
    free(res);

    bool found(false);
    for (std::size_t i = 0; i < testing::testresult::clients.size(); i++) {
        if (to_string(client_name) == testing::testresult::clients[i]) {
            found = true;
            break;
        }
    }
    ASSERT_TRUE(found);

    // We should be able to add as many clients as we like!
    for (int i = 0; i < 10; i++) {
        std::stringstream ss;
        ss << ""extra client "" << i;
        testing::testresult::error = """";
        res = toggl_create_client(app.ctx(),
                                  wid,
                                  to_char_t(ss.str()));
        ASSERT_EQ("""", testing::testresult::error);
        ASSERT_TRUE(res);
        free(res);
    }

    // But none with an existing client name
    testing::testresult::error = """";
    res = toggl_create_client(app.ctx(),
                              wid,
                              client_name);
    ASSERT_FALSE(res);
    ASSERT_EQ(""Client name already exists"", testing::testresult::error);
}

TEST(toggl_api, toggl_continue) {
    testing::App app;

    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    auto te = testing::testresult::time_entry_by_id(89833438);
    std::string guid = te.GUID();

    testing::testresult::error = """";
    ASSERT_TRUE(toggl_continue(app.ctx(), to_char_t(guid)));
    ASSERT_NE(guid, testing::testresult::timer_state.GUID());
    ASSERT_EQ(""More work"", testing::testresult::timer_state.Description());
}

TEST(toggl_api, toggl_continue_in_manual_mode) {
    testing::App app;

    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    ASSERT_TRUE(toggl_set_settings_manual_mode(app.ctx(), true));
    ASSERT_TRUE(testing::testresult::settings.manual_mode);

    auto te = testing::testresult::time_entry_by_id(89833438);
    std::string guid = te.GUID();

    testing::testresult::error = """";
    testing::testresult::editor_state = TimeEntry();
    testing::testresult::timer_state = TimeEntry();

    ASSERT_TRUE(toggl_continue(app.ctx(), to_char_t(guid)));

    ASSERT_NE(guid, testing::testresult::timer_state.GUID());

    ASSERT_FALSE(testing::testresult::timer_state.Start());
    ASSERT_FALSE(testing::testresult::timer_state.DurationInSeconds());

    ASSERT_NE("""", testing::testresult::editor_state.GUID());
}

TEST(toggl_api, toggl_check_view_struct_size) {
    char_t *err = toggl_check_view_struct_size(
        sizeof(TogglTimeEntryView),
        sizeof(TogglAutocompleteView),
        sizeof(TogglGenericView),
        sizeof(TogglSettingsView),
        sizeof(TogglAutotrackerRuleView));
    if (err) {
        ASSERT_EQ("""", to_string(err));
    }
    ASSERT_FALSE(err);
    free(err);
}

TEST(toggl_api, toggl_view_time_entry_list) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));
    toggl_view_time_entry_list(app.ctx());
    ASSERT_EQ(std::size_t(5), testing::testresult::time_entries.size());
}

TEST(toggl_api, toggl_edit) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));
    auto te = testing::testresult::time_entry_by_id(89837259);
    std::string guid = te.GUID();
    bool_t edit_running_time_entry = false;
    auto focused_field = STR(""description"");
    toggl_edit(app.ctx(), to_char_t(guid), edit_running_time_entry,
               focused_field);
    ASSERT_EQ(guid, testing::testresult::editor_state.GUID());
    ASSERT_EQ(""description"", testing::testresult::editor_focused_field_name);
}

TEST(toggl_api, toggl_set_online) {
    // App can trigger online state before lib is initialized
    toggl_set_online(0);

    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));
    toggl_set_online(app.ctx());
}

TEST(toggl_api, toggl_set_sleep) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));
    toggl_set_sleep(app.ctx());
}

TEST(toggl_api, toggl_set_wake) {
    // App can trigger awake state from computer before lib is initialized
    toggl_set_wake(0);

    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));
    toggl_set_wake(app.ctx());
}

TEST(toggl_api, toggl_timeline_toggle_recording) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));
    ASSERT_TRUE(toggl_timeline_is_recording_enabled(app.ctx()));

    ASSERT_TRUE(toggl_timeline_toggle_recording(app.ctx(), true));
    ASSERT_TRUE(toggl_timeline_is_recording_enabled(app.ctx()));

    ASSERT_TRUE(toggl_timeline_toggle_recording(app.ctx(), false));
    ASSERT_FALSE(toggl_timeline_is_recording_enabled(app.ctx()));
}

TEST(toggl_api, toggl_edit_preferences) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    testing::testresult::open_settings = false;
    toggl_edit_preferences(app.ctx());
    ASSERT_TRUE(testing::testresult::open_settings);
}

TEST(toggl_api, toggl_continue_latest) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    testing::testresult::error = noError;
    bool res = toggl_continue_latest(app.ctx(), false);
    ASSERT_EQ(noError, testing::testresult::error);
    ASSERT_TRUE(res);
    ASSERT_EQ(""arendus käib"", testing::testresult::timer_state.Description());
}

TEST(toggl_api, toggl_continue_latest_with_manual_mode) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    ASSERT_TRUE(toggl_set_settings_manual_mode(app.ctx(), true));
    ASSERT_TRUE(testing::testresult::settings.manual_mode);

    testing::testresult::error = noError;
    testing::testresult::editor_state = TimeEntry();
    testing::testresult::timer_state = TimeEntry();

    ASSERT_TRUE(toggl_continue_latest(app.ctx(), false));

    ASSERT_EQ(noError, testing::testresult::error);

    ASSERT_FALSE(testing::testresult::timer_state.Start());
    ASSERT_FALSE(testing::testresult::timer_state.DurationInSeconds());

    ASSERT_NE("""", testing::testresult::editor_state.GUID());
}

TEST(toggl_api, toggl_delete_time_entry) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    toggl_view_time_entry_list(app.ctx());
    ASSERT_EQ(std::size_t(5), testing::testresult::time_entries.size());

    auto te = testing::testresult::time_entry_by_id(89837259);
    std::string guid = te.GUID();
    ASSERT_TRUE(toggl_delete_time_entry(app.ctx(), to_char_t(guid)));

    toggl_view_time_entry_list(app.ctx());
    ASSERT_EQ(std::size_t(4), testing::testresult::time_entries.size());
}

TEST(toggl_api, toggl_set_time_entry_duration) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    auto te = testing::testresult::time_entry_by_id(89818605);
    std::string guid = te.GUID();

    ASSERT_TRUE(toggl_set_time_entry_duration(app.ctx(),
                to_char_t(guid), STR(""2 hours"")));

    toggl_view_time_entry_list(app.ctx());

    for (std::size_t i = 0; i < testing::testresult::time_entries.size();
            i++) {
        if (testing::testresult::time_entries[i].GUID() == guid) {
            te = testing::testresult::time_entries[i];
            break;
        }
    }
    ASSERT_EQ(guid, te.GUID());
    ASSERT_EQ(7200, te.DurationInSeconds());
}

TEST(toggl_api, toggl_set_time_entry_description) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    auto te = testing::testresult::time_entry_by_id(89818605);
    std::string guid = te.GUID();

    ASSERT_TRUE(toggl_set_time_entry_description(app.ctx(),
                to_char_t(guid), STR(""this is a nuclear test"")));

    toggl_view_time_entry_list(app.ctx());

    for (std::size_t i = 0; i < testing::testresult::time_entries.size();
            i++) {
        if (testing::testresult::time_entries[i].GUID() == guid) {
            te = testing::testresult::time_entries[i];
            break;
        }
    }
    ASSERT_EQ(guid, te.GUID());
    ASSERT_EQ(""this is a nuclear test"", te.Description());
}

TEST(toggl_api, toggl_stop) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    testing::testresult::timer_state = TimeEntry();

    char_t *guid = toggl_start(app.ctx(), STR(""test""), STR(""""), 0, 0, 0, 0, false, 0, 0);
    ASSERT_TRUE(guid);
    free(guid);

    ASSERT_FALSE(testing::testresult::timer_state.GUID().empty());

    ASSERT_TRUE(toggl_stop(app.ctx(), false));
    ASSERT_TRUE(testing::testresult::timer_state.GUID().empty());
}

TEST(toggl_api, toggl_with_default_project) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    // Clear default project ID
    // Check that project ID and task ID are cleared

    ASSERT_TRUE(toggl_set_default_project(app.ctx(), 0, 0));
    char_t *s = toggl_get_default_project_name(app.ctx());
    ASSERT_FALSE(s);
    free(s);

    // Start a time entry, no defaults should apply

    testing::testresult::timer_state = TimeEntry();

    char_t *guid = toggl_start(app.ctx(), STR(""test""), STR(""""), 0, 0, 0, 0, false, 0, 0);
    ASSERT_TRUE(guid);
    free(guid);

    ASSERT_FALSE(testing::testresult::timer_state.GUID().empty());
    ASSERT_FALSE(testing::testresult::timer_state.PID());
    ASSERT_FALSE(testing::testresult::timer_state.TID());

    // Set default project ID.
    // Task ID should remain 0

    const uint64_t existing_project_id = 2598305;
    const std::string existing_project_name = ""Testing stuff"";
    ASSERT_TRUE(toggl_set_default_project(app.ctx(), existing_project_id, 0));
    s = toggl_get_default_project_name(app.ctx());
    ASSERT_TRUE(s);
    ASSERT_EQ(existing_project_name, to_string(s));
    free(s);

    // Start timer, the default project should apply

    testing::testresult::timer_state = TimeEntry();

    guid = toggl_start(app.ctx(), STR(""test""), STR(""""), 0, 0, 0, 0, false, 0, 0);
    ASSERT_TRUE(guid);
    free(guid);

    ASSERT_FALSE(testing::testresult::timer_state.GUID().empty());
    ASSERT_EQ(existing_project_id, testing::testresult::timer_state.PID());
    ASSERT_EQ(0, testing::testresult::timer_state.TID());

    // Set default task

    const uint64_t existing_task_id = 1879027;
    ASSERT_TRUE(toggl_set_default_project(app.ctx(), 0, existing_task_id));
    s = toggl_get_default_project_name(app.ctx());
    ASSERT_TRUE(s);
    ASSERT_EQ(""dadsad. Testing stuff"", to_string(s));
    free(s);

    // Start timer, the default task should apply

    testing::testresult::timer_state = TimeEntry();

    guid = toggl_start(app.ctx(), STR(""more testing""), STR(""""), 0, 0, 0, 0, false, 0, 0);
    ASSERT_TRUE(guid);
    free(guid);

    ASSERT_FALSE(testing::testresult::timer_state.GUID().empty());
    ASSERT_EQ(existing_project_id, testing::testresult::timer_state.PID());
    ASSERT_EQ(existing_task_id, testing::testresult::timer_state.TID());

    // Setting task ID to 0 should not affect project ID

    ASSERT_TRUE(toggl_set_default_project(app.ctx(), existing_project_id, 0));
    s = toggl_get_default_project_name(app.ctx());
    ASSERT_TRUE(s);
    ASSERT_EQ(existing_project_name, to_string(s));
    free(s);

    // Setting task ID to not 0 should attach a project ID, too

    const uint64_t another_task_id = 1894794;
    ASSERT_TRUE(toggl_set_default_project(app.ctx(), 0, another_task_id));
    s = toggl_get_default_project_name(app.ctx());
    ASSERT_TRUE(s);
    ASSERT_EQ(""blog (writing). Testing stuff"", to_string(s));
    free(s);

    // Setting project ID to 0 should not clear out task ID

    ASSERT_TRUE(toggl_set_default_project(app.ctx(), 0, existing_task_id));
    s = toggl_get_default_project_name(app.ctx());
    ASSERT_TRUE(s);
    ASSERT_EQ(""dadsad. Testing stuff"", to_string(s));
    free(s);

    ASSERT_TRUE(toggl_set_default_project(app.ctx(), 0, 0));
    s = toggl_get_default_project_name(app.ctx());
    ASSERT_FALSE(s);
    free(s);
}

TEST(toggl_api, toggl_start) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    testing::testresult::timer_state = TimeEntry();

    char_t *guid = toggl_start(app.ctx(), STR(""test""), STR(""""), 0, 0, 0, 0, false, 0, 0);
    ASSERT_TRUE(guid);
    free(guid);

    ASSERT_FALSE(testing::testresult::timer_state.GUID().empty());
}

TEST(toggl_api, concurrency) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    const int kThreadCount = 2;

    std::vector<Poco::Thread *> threads;
    for (int i = 0; i < kThreadCount; i++) {
        std::stringstream ss;
        ss << ""thread "" << i;
        Poco::Thread *thread = new Poco::Thread(ss.str());
        threads.push_back(thread);
    }

    std::vector<testing::ApiClient *> runnables;
    for (int i = 0; i < kThreadCount; i++) {
        std::stringstream ss;
        ss << ""runnable "" << i;
        testing::ApiClient *runnable = new testing::ApiClient(&app, ss.str());
        runnables.push_back(runnable);
    }

    for (int i = 0; i < kThreadCount; i++) {
        threads[i]->start(*runnables[i]);
    }

    Poco::Thread::sleep(2000);

    for (int i = 0; i < kThreadCount; i++) {
        Poco::Thread *thread = threads[i];
        testing::ApiClient *runnable = runnables[i];
        while (!runnable->finished()) {
            Poco::Thread::sleep(10);
        }
        thread->join();
        delete runnable;
        delete thread;
    }
}

TEST(toggl_api, toggl_set_keep_end_times_fixed) {
    testing::App app;

    toggl_set_keep_end_time_fixed(app.ctx(), true);
    ASSERT_TRUE(toggl_get_keep_end_time_fixed(app.ctx()));

    toggl_set_keep_end_time_fixed(app.ctx(), false);
    ASSERT_FALSE(toggl_get_keep_end_time_fixed(app.ctx()));
}

TEST(toggl_api, toggl_set_window_maximized) {
    testing::App app;

    toggl_set_window_maximized(app.ctx(), true);
    ASSERT_TRUE(toggl_get_window_maximized(app.ctx()));

    toggl_set_window_maximized(app.ctx(), false);
    ASSERT_FALSE(toggl_get_window_maximized(app.ctx()));
}

TEST(toggl_api, toggl_set_window_minimized) {
    testing::App app;

    toggl_set_window_minimized(app.ctx(), true);
    ASSERT_TRUE(toggl_get_window_minimized(app.ctx()));

    toggl_set_window_minimized(app.ctx(), false);
    ASSERT_FALSE(toggl_get_window_minimized(app.ctx()));
}

TEST(toggl_api, toggl_set_window_edit_size_height) {
    testing::App app;

    toggl_set_window_edit_size_height(app.ctx(), 0);
    ASSERT_EQ(0, toggl_get_window_edit_size_height(app.ctx()));

    toggl_set_window_edit_size_height(app.ctx(), 123);
    ASSERT_EQ(123, toggl_get_window_edit_size_height(app.ctx()));
}

TEST(toggl_api, toggl_set_window_edit_size_width) {
    testing::App app;

    toggl_set_window_edit_size_width(app.ctx(), -10);
    ASSERT_EQ(-10, toggl_get_window_edit_size_width(app.ctx()));

    toggl_set_window_edit_size_width(app.ctx(), 1234);
    ASSERT_EQ(1234, toggl_get_window_edit_size_width(app.ctx()));
}

TEST(toggl_api, toggl_set_key_start) {
    testing::App app;

    toggl_set_key_start(app.ctx(), STR(""a""));
    char_t *res = toggl_get_key_start(app.ctx());
    ASSERT_TRUE(res);
    ASSERT_EQ(""a"", to_string(res));
    free(res);

    toggl_set_key_start(app.ctx(), STR(""""));
    res = toggl_get_key_start(app.ctx());
    ASSERT_TRUE(res);
    ASSERT_EQ("""", to_string(res));
    free(res);
}

TEST(toggl_api, toggl_set_key_show) {
    testing::App app;

    toggl_set_key_show(app.ctx(), STR(""a""));
    char_t *res = toggl_get_key_show(app.ctx());
    ASSERT_TRUE(res);
    ASSERT_EQ(""a"", to_string(res));
    free(res);

    toggl_set_key_show(app.ctx(), STR(""""));
    res = toggl_get_key_show(app.ctx());
    ASSERT_TRUE(res);
    ASSERT_EQ("""", to_string(res));
    free(res);
}

TEST(toggl_api, toggl_set_key_modifier_start) {
    testing::App app;

    toggl_set_key_modifier_start(app.ctx(), STR(""a""));
    char_t *res = toggl_get_key_modifier_start(app.ctx());
    ASSERT_TRUE(res);
    ASSERT_EQ(""a"", to_string(res));
    free(res);

    toggl_set_key_modifier_start(app.ctx(), STR(""""));
    res = toggl_get_key_modifier_start(app.ctx());
    ASSERT_TRUE(res);
    ASSERT_EQ("""", to_string(res));
    free(res);
}

TEST(toggl_api, toggl_start_with_tags) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    testing::testresult::timer_state = TimeEntry();

    char_t *guid = toggl_start(app.ctx(), STR(""test""), STR(""""), 0, 0, 0, STR(""a\\tb\\tc""),
                               false, 0, 0);
    ASSERT_TRUE(guid);
    free(guid);

    ASSERT_FALSE(testing::testresult::timer_state.GUID().empty());
    ASSERT_EQ(std::string(""a\\tb\\tc""), testing::testresult::timer_state.Tags());
}

TEST(toggl_api, toggl_start_with_open_editor_on_shortcut_setting) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    ASSERT_TRUE(toggl_set_settings_open_editor_on_shortcut(app.ctx(), false));

    testing::testresult::editor_state = TimeEntry();

    char_t *guid = toggl_start(app.ctx(), STR(""test""), STR(""""), 0, 0, 0, 0, false, 0, 0);
    ASSERT_TRUE(guid);
    free(guid);

    ASSERT_TRUE(testing::testresult::editor_state.GUID().empty());

    ASSERT_TRUE(toggl_set_settings_open_editor_on_shortcut(app.ctx(), true));

    testing::testresult::editor_state = TimeEntry();

    guid = toggl_start(app.ctx(), STR(""test""), STR(""""), 0, 0, 0, 0, false, 0, 0);
    ASSERT_TRUE(guid);

    ASSERT_EQ(to_string(guid), testing::testresult::editor_state.GUID());
    free(guid);
}

TEST(toggl_api, toggl_set_time_entry_billable) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    testing::testresult::timer_state = TimeEntry();

    char_t *res = toggl_start(app.ctx(), STR(""test""), STR(""""), 0, 0, 0, 0, false, 0, 0);
    ASSERT_TRUE(res);
    free(res);

    std::string guid = testing::testresult::timer_state.GUID();
    ASSERT_FALSE(guid.empty());

    ASSERT_TRUE(toggl_set_time_entry_billable(app.ctx(), to_char_t(guid), true));
    ASSERT_TRUE(testing::testresult::timer_state.Billable());

    ASSERT_TRUE(toggl_set_time_entry_billable(app.ctx(), to_char_t(guid), false));
    ASSERT_FALSE(testing::testresult::timer_state.Billable());
}

TEST(toggl_api, toggl_set_time_entry_tags) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    testing::testresult::timer_state = TimeEntry();

    char_t *res = toggl_start(app.ctx(), STR(""test""), STR(""""), 0, 0, 0, 0, false, 0, 0);
    ASSERT_TRUE(res);
    free(res);

    std::string guid = testing::testresult::timer_state.GUID();
    ASSERT_FALSE(guid.empty());

    ASSERT_TRUE(toggl_set_time_entry_tags(app.ctx(), to_char_t(guid), STR(""a|b|c"")));
    ASSERT_EQ(""a|b|c"", testing::testresult::timer_state.Tags());

    ASSERT_TRUE(toggl_set_time_entry_tags(app.ctx(), to_char_t(guid), STR(""a"")));
    ASSERT_EQ(""a"", testing::testresult::timer_state.Tags());

    ASSERT_TRUE(toggl_set_time_entry_tags(app.ctx(), to_char_t(guid), STR("""")));
    ASSERT_EQ("""", testing::testresult::timer_state.Tags());
}

TEST(toggl_api, toggl_parse_duration_string_into_seconds) {
    int64_t seconds = toggl_parse_duration_string_into_seconds(STR(""15 seconds""));
    ASSERT_EQ(15, seconds);
}

TEST(toggl_api,
     toggl_parse_duration_string_into_seconds_with_no_duration_string) {
    int64_t seconds = toggl_parse_duration_string_into_seconds(0);
    ASSERT_EQ(0, seconds);
}

TEST(toggl_api, toggl_discard_time_at_with_no_guid) {
    testing::App app;

    ASSERT_FALSE(toggl_discard_time_at(app.ctx(), 0, time(0), false));
}

TEST(toggl_api, toggl_discard_time_at_with_no_stop_time) {
    testing::App app;

    ASSERT_FALSE(toggl_discard_time_at(app.ctx(), STR(""some fake guid""), 0, false));
}

TEST(toggl_api, toggl_discard_time_at) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    testing::testresult::timer_state = TimeEntry();

    // Start a time entry

    char_t *res = toggl_start(app.ctx(), STR(""test""), STR(""""), 0, 0, 0, 0, false, 0, 0);
    ASSERT_TRUE(res);
    free(res);

    Poco::UInt64 started = time(0);
    std::string guid = testing::testresult::timer_state.GUID();
    ASSERT_FALSE(guid.empty());

    // Discard the time entry at some point

    Poco::UInt64 stopped = time(0);
    ASSERT_TRUE(toggl_discard_time_at(app.ctx(), to_char_t(guid), stopped, false));
    ASSERT_NE(guid, testing::testresult::timer_state.GUID());
    ASSERT_TRUE(testing::testresult::timer_state.GUID().empty());

    TimeEntry te;
    for (std::size_t i = 0; i < testing::testresult::time_entries.size();
            i++) {
        if (testing::testresult::time_entries[i].GUID() == guid) {
            te = testing::testresult::time_entries[i];
            break;
        }
    }
    ASSERT_EQ(guid, te.GUID());
    ASSERT_TRUE(started == te.Start() || started + 1 == te.Start());
    ASSERT_TRUE(stopped == te.Stop() || stopped + 1 == te.Stop());

    // Start another time entry

    res = toggl_start(app.ctx(), STR(""test 2""), STR(""""), 0, 0, 0, 0, false, 0, 0);
    ASSERT_TRUE(res);
    free(res);

    started = time(0);
    guid = testing::testresult::timer_state.GUID();
    ASSERT_FALSE(guid.empty());

    // Discard the time entry, by creating a new one

    stopped = time(0);
    ASSERT_TRUE(toggl_discard_time_at(app.ctx(), to_char_t(guid), stopped, true));
    ASSERT_NE(guid, testing::testresult::timer_state.GUID());

    te = TimeEntry();
    for (std::size_t i = 0; i < testing::testresult::time_entries.size();
            i++) {
        if (testing::testresult::time_entries[i].GUID() == guid) {
            te = testing::testresult::time_entries[i];
            break;
        }
    }
    ASSERT_EQ(guid, te.GUID());
    ASSERT_TRUE(started == te.Start() || started + 1 == te.Start());
    ASSERT_TRUE(stopped == te.Stop() || stopped + 1 == te.Stop());

    // Check that a new time entry was created

    ASSERT_TRUE(!testing::testresult::timer_state.GUID().empty());
    ASSERT_EQ(stopped, testing::testresult::timer_state.Start());
    ASSERT_TRUE(testing::testresult::timer_state.IsTracking());
    ASSERT_EQ("""", testing::testresult::timer_state.Description());
}

TEST(toggl_api, toggl_search_help_articles) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    testing::testresult::help_article_names.clear();
    toggl_search_help_articles(app.ctx(), STR(""Tracking""));
    ASSERT_TRUE(testing::testresult::help_article_names.size());
    ASSERT_TRUE(std::find(
        testing::testresult::help_article_names.begin(),
        testing::testresult::help_article_names.end(),
        ""Tracking time"") !=
                testing::testresult::help_article_names.end());

    testing::testresult::help_article_names.clear();
    toggl_search_help_articles(app.ctx(), STR(""basic""));
    ASSERT_TRUE(testing::testresult::help_article_names.size());
    ASSERT_TRUE(std::find(
        testing::testresult::help_article_names.begin(),
        testing::testresult::help_article_names.end(),
        ""Basics"") !=
                testing::testresult::help_article_names.end());
}

TEST(toggl_api, toggl_feedback_send) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    ASSERT_TRUE(toggl_feedback_send(app.ctx(),
                                    STR(""Help""), STR(""I need help""), STR("""")));
}

TEST(toggl_api, toggl_set_time_entry_date) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    toggl::TimeEntry te = testing::testresult::time_entry_by_id(89818605);
    std::string guid = te.GUID();

    Poco::DateTime datetime(Poco::Timestamp::fromEpochTime(te.Start()));
    ASSERT_EQ(2013, datetime.year());
    ASSERT_EQ(9, datetime.month());
    ASSERT_EQ(5, datetime.day());
    ASSERT_EQ(6, datetime.hour());
    ASSERT_EQ(33, datetime.minute());
    ASSERT_EQ(50, datetime.second());

    // 10/27/2014 @ 12:51pm in UTC.
    int unix_timestamp(1414414311);
    ASSERT_TRUE(toggl_set_time_entry_date(app.ctx(),
                                          to_char_t(guid),
                                          unix_timestamp));

    te = testing::testresult::time_entry_by_id(89818605);
    datetime = Poco::DateTime(Poco::Timestamp::fromEpochTime(te.Start()));
    ASSERT_EQ(2014, datetime.year());
    ASSERT_EQ(10, datetime.month());
    ASSERT_EQ(27, datetime.day());
    ASSERT_EQ(33, datetime.minute());
    ASSERT_EQ(50, datetime.second());
}

TEST(toggl_api, toggl_set_time_entry_start) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    toggl::TimeEntry te = testing::testresult::time_entry_by_id(89818605);
    std::string guid = te.GUID();

    Poco::DateTime datetime(Poco::Timestamp::fromEpochTime(te.Start()));
    ASSERT_EQ(2013, datetime.year());
    ASSERT_EQ(9, datetime.month());
    ASSERT_EQ(5, datetime.day());
    ASSERT_EQ(6, datetime.hour());
    ASSERT_EQ(33, datetime.minute());
    ASSERT_EQ(50, datetime.second());

    ASSERT_TRUE(toggl_set_time_entry_start(app.ctx(), to_char_t(guid), STR(""12:34"")));

    te = testing::testresult::time_entry_by_id(89818605);
    Poco::LocalDateTime local =
        Poco::DateTime(Poco::Timestamp::fromEpochTime(te.Start()));
    ASSERT_EQ(2013, local.year());
    ASSERT_EQ(9, local.month());
    ASSERT_EQ(5, local.day());
    ASSERT_EQ(12, local.hour());
    ASSERT_EQ(34, local.minute());
    ASSERT_EQ(50, local.second());

    // Setting an invalid value should not crash the app
    ASSERT_FALSE(toggl_set_time_entry_start(app.ctx(), to_char_t(guid), STR(""12:558"")));
}

TEST(toggl_api, toggl_set_time_entry_end) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    toggl::TimeEntry te = testing::testresult::time_entry_by_id(89818605);
    std::string guid = te.GUID();

    Poco::DateTime datetime(Poco::Timestamp::fromEpochTime(te.Stop()));
    ASSERT_EQ(2013, datetime.year());
    ASSERT_EQ(9, datetime.month());
    ASSERT_EQ(5, datetime.day());
    ASSERT_EQ(8, datetime.hour());
    ASSERT_EQ(19, datetime.minute());
    ASSERT_EQ(46, datetime.second());

    ASSERT_TRUE(toggl_set_time_entry_end(app.ctx(), to_char_t(guid), STR(""18:29"")));

    te = testing::testresult::time_entry_by_id(89818605);
    Poco::LocalDateTime local =
        Poco::DateTime(Poco::Timestamp::fromEpochTime(te.Stop()));
    ASSERT_EQ(2013, local.year());
    ASSERT_EQ(9, local.month());
    ASSERT_EQ(5, local.day());
    ASSERT_EQ(18, local.hour());
    ASSERT_EQ(29, local.minute());
    ASSERT_EQ(46, local.second());

    // Setting an invalid value should not crash the app
    ASSERT_FALSE(toggl_set_time_entry_end(app.ctx(), to_char_t(guid), STR(""12:558"")));
}

TEST(toggl_api, toggl_set_time_entry_end_prefers_same_day) {
    testing::App app;
    std::string json =
        loadFromTestDataDir(std::string(""time_entry_ending_tomorrow.json""));
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    toggl::TimeEntry te = testing::testresult::time_entry_by_id(89818605);
    std::string guid = te.GUID();

    // Set start time so it will be local time
    ASSERT_TRUE(toggl_set_time_entry_date(app.ctx(), to_char_t(guid), time(0)));
    ASSERT_TRUE(toggl_set_time_entry_start(app.ctx(), to_char_t(guid), STR(""06:33"")));

    ASSERT_TRUE(toggl_set_time_entry_end(app.ctx(), to_char_t(guid), STR(""06:34"")));

    // take the updated time entry
    te = testing::testresult::time_entry_by_id(89818605);

    Poco::DateTime start(Poco::Timestamp::fromEpochTime(te.Start()));
    Poco::DateTime end(Poco::Timestamp::fromEpochTime(te.Stop()));
    ASSERT_EQ(start.year(), end.year());
    ASSERT_EQ(start.month(), end.month());
    ASSERT_EQ(start.day(), end.day());
}

TEST(toggl_api, toggl_autotracker_add_rule) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    testing::testresult::error = noError;

    const uint64_t existing_project_id = 2598305;

    int64_t rule_id = toggl_autotracker_add_rule(
        app.ctx(), STR(""delfi""), existing_project_id, 0);
    ASSERT_EQ(noError, testing::testresult::error);
    ASSERT_TRUE(rule_id);

    testing::testresult::error = noError;
    rule_id = toggl_autotracker_add_rule(
        app.ctx(), STR(""delfi""), existing_project_id, 0);
    ASSERT_EQ(""rule already exists"", testing::testresult::error);
    ASSERT_FALSE(rule_id);

    const uint64_t existing_task_id = 1879027;

    testing::testresult::error = noError;
    rule_id = toggl_autotracker_add_rule(
        app.ctx(), STR(""with task""), 0, existing_task_id);
    ASSERT_EQ(noError, testing::testresult::error);
    ASSERT_TRUE(rule_id);

    testing::testresult::error = noError;
    rule_id = toggl_autotracker_add_rule(
        app.ctx(),
        STR(""with task and project""),
        existing_project_id,
        existing_task_id);
    ASSERT_EQ(noError, testing::testresult::error);
    ASSERT_TRUE(rule_id);
}

TEST(toggl_api, toggl_set_default_project) {
    testing::App app;
    std::string json = loadTestData();
    ASSERT_TRUE(testing_set_logged_in_user(app.ctx(), json.c_str()));

    char_t *default_project_name = toggl_get_default_project_name(app.ctx());
    ASSERT_FALSE(default_project_name);
    free(default_project_name);

    testing::testresult::error = noError;
    bool_t res = toggl_set_default_project(app.ctx(), 123, 0);
    ASSERT_NE(noError, testing::testresult::error);
    ASSERT_FALSE(res);

    default_project_name = toggl_get_default_project_name(app.ctx());
    ASSERT_FALSE(default_project_name);
    free(default_project_name);

    const uint64_t existing_project_id = 2598305;
    const std::string existing_project_name = ""Testing stuff"";

    testing::testresult::error = noError;
    res = toggl_set_default_project(app.ctx(), existing_project_id, 0);
    ASSERT_TRUE(res);

    default_project_name = toggl_get_default_project_name(app.ctx());
    ASSERT_TRUE(default_project_name);
    ASSERT_EQ(existing_project_name, to_string(default_project_name));
    free(default_project_name);

    testing::testresult::error = noError;
    res = toggl_set_default_project(app.ctx(), 0, 0);
    ASSERT_TRUE(res);

    default_project_name = toggl_get_default_project_name(app.ctx());
    ASSERT_FALSE(default_project_name);
    free(default_project_name);
}

}  // namespace toggl

int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}
",16144,True,3388.4859729230807,median
"// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

#include <algorithm>
#include <cfenv>
#include <vector>

#include ""gtest/gtest.h""
#include ""test/common/quantization_test_utils.h""
#include ""test/common/tensor_op_test_utils.h""
#include ""test/common/cuda_op_test_utils.h""
#include ""test/providers/provider_test_utils.h""
#include ""core/util/qmath.h""
#include ""core/quantization/quantization.h""

namespace onnxruntime {
namespace test {

enum class EP : char {
  CPU,
  CUDA
};


// input:      [batch_size, sequence_length, hidden_size]
// weights:    [hidden_size, 3 * hidden_size]
// bias:       [3 * hidden_size]
// mask_index: [batch_size]
// output:     [batch_size, sequence_length, hidden_size]
template <typename QInput, typename QWeight, EP ep>
void RunQAttention(const std::vector<float>& input_data,
                   const std::vector<float>& weights_data,
                   const std::vector<float>& bias_data,
                   const std::vector<int32_t>& mask_index_data,
                   const std::vector<float>& output_data,
                   quantization::Params<QInput>& input_quant_params,
                   quantization::Params<QWeight>& weight_quant_params,
                   int batch_size,
                   int sequence_length,
                   int hidden_size,
                   int number_of_heads,
                   bool is_unidirectional = false,
                   bool use_float16 = false,
                   int input_hidden_size = 0) {
  input_hidden_size = (input_hidden_size == 0) ? hidden_size : input_hidden_size;

  OpTester tester(""QAttention"", 1, onnxruntime::kMSDomain);
  tester.AddAttribute<int64_t>(""num_heads"", static_cast<int64_t>(number_of_heads));
  if (is_unidirectional) {
    tester.AddAttribute<int64_t>(""unidirectional"", 1);
  }

  std::vector<int64_t> input_dims = {batch_size, sequence_length, input_hidden_size};
  std::vector<int64_t> weights_dims = {input_hidden_size, static_cast<int64_t>(3 * hidden_size)};
  std::vector<int64_t> bias_dims = {static_cast<int64_t>(3 * hidden_size)};
  std::vector<int64_t> mask_index_dims = {batch_size};
  std::vector<int64_t> output_dims = {batch_size, sequence_length, hidden_size};

  if (input_quant_params.scale != 0.0f) {
    tester.AddInput<QInput>(""input"",
                            input_dims,
                            QuantizeTestVector<QInput>(input_data, input_quant_params));
    tester.AddInput<QWeight>(""weight"",
                             weights_dims,
                             QuantizeTestVector<QWeight>(weights_data, weight_quant_params));
  } else {
    bool force_symmetric = false;
    if constexpr (ep == EP::CUDA) {
      force_symmetric = true;
    }
    tester.AddInput<QInput>(
        ""input"",
        input_dims,
        QuantizeLinearTestVector<QInput>(input_data, input_quant_params, force_symmetric));
    tester.AddInput<QWeight>(
        ""weight"",
        weights_dims,
        QuantizeLinearTestVector<QWeight>(weights_data, weight_quant_params, force_symmetric));
  }
  if (use_float16) {
    tester.AddInput<MLFloat16>(""bias"", bias_dims, ToFloat16(bias_data));
    tester.AddInput<MLFloat16>(""input_scale"", {1}, ToFloat16({input_quant_params.scale}));
    tester.AddInput<MLFloat16>(""weight_scale"", {1}, ToFloat16({weight_quant_params.scale}));
    tester.AddOutput<MLFloat16>(""output"", output_dims, ToFloat16(output_data));
  } else {
    tester.AddInput<float>(""bias"", bias_dims, bias_data);
    tester.AddInput<float>(""input_scale"", {1}, {input_quant_params.scale});
    tester.AddInput<float>(""weight_scale"", {1}, {weight_quant_params.scale});
    tester.AddOutput<float>(""output"", output_dims, output_data);
  }

  if (mask_index_data.size() > 0) {
    tester.AddInput<int32_t>(""mask_index"", mask_index_dims, mask_index_data);
  } else {
    // mask index is optional.
    tester.AddOptionalInputEdge<int32_t>();
  }

  tester.AddInput<QInput>(""input_zero_point"", {1}, {input_quant_params.zero_point});
  tester.AddInput<QWeight>(""weight_zero_point"", {1}, {weight_quant_params.zero_point});

  if constexpr (ep == EP::CUDA) {
    std::vector<std::unique_ptr<IExecutionProvider>> execution_providers;
    execution_providers.push_back(DefaultCudaExecutionProvider());
    tester.Run(OpTester::ExpectResult::kExpectSuccess, """", {kTensorrtExecutionProvider}, nullptr, &execution_providers);
  } else {
    std::vector<std::unique_ptr<IExecutionProvider>> execution_providers;
    execution_providers.push_back(DefaultCpuExecutionProvider());
    tester.Run(OpTester::ExpectResult::kExpectSuccess, """", {kTensorrtExecutionProvider}, nullptr, &execution_providers);
  }
}

static void RunQAttentionCUDA(
    const std::vector<float>& input_data,
    const std::vector<float>& weights_data,
    const std::vector<float>& bias_data,
    const std::vector<int32_t>& mask_index_data,
    const std::vector<float>& output_data,
    int batch_size,
    int sequence_length,
    int hidden_size,
    int number_of_heads,
    bool use_special_quantize_parameter = true,
    bool is_unidirectional = false,
    bool use_float16 = false,
    int input_hidden_size = 0) {
  int min_cuda_architecture = 530;
  bool enable_cuda = HasCudaEnvironment(min_cuda_architecture);

  if (enable_cuda) {
    quantization::Params<int8_t> input_quant_params = {0.0f, 0};
    quantization::Params<int8_t> weights_quant_params = {0.0f, 0};
    if (use_special_quantize_parameter) {
      input_quant_params.scale = 0.1f;
      weights_quant_params.scale = 0.1f;
    }
    RunQAttention<int8_t, int8_t, EP::CUDA>(
        input_data, weights_data, bias_data, mask_index_data, output_data, input_quant_params, weights_quant_params,
        batch_size, sequence_length, hidden_size, number_of_heads, is_unidirectional, use_float16, input_hidden_size);
  }
}

static void RunQAttentionU8U8(
    const std::vector<float>& input_data,
    const std::vector<float>& weights_data,
    const std::vector<float>& bias_data,
    const std::vector<int32_t>& mask_index_data,
    const std::vector<float>& output_data,
    int batch_size,
    int sequence_length,
    int hidden_size,
    int number_of_heads,
    bool use_special_quantize_parameter = true,
    bool is_unidirectional = false,
    int input_hidden_size = 0) {
  quantization::Params<uint8_t> input_quant_params = {0.0f, 0};
  quantization::Params<uint8_t> weights_quant_params = {0.0f, 0};
  if (use_special_quantize_parameter) {
    input_quant_params.scale = 0.1f;
    weights_quant_params.scale = 0.1f;
    input_quant_params.zero_point = 128;
    weights_quant_params.zero_point = 128;
  }

  RunQAttention<uint8_t, uint8_t, EP::CPU>(
      input_data, weights_data, bias_data, mask_index_data, output_data, input_quant_params, weights_quant_params,
      batch_size, sequence_length, hidden_size, number_of_heads, is_unidirectional, false, input_hidden_size);
}

static void RunQAttentionU8S8(
    const std::vector<float>& input_data,
    const std::vector<float>& weights_data,
    const std::vector<float>& bias_data,
    const std::vector<int32_t>& mask_index_data,
    const std::vector<float>& output_data,
    int batch_size,
    int sequence_length,
    int hidden_size,
    int number_of_heads,
    bool use_special_quantize_parameter = true,
    bool is_unidirectional = false,
    int input_hidden_size = 0) {
  quantization::Params<uint8_t> input_quant_params(/*scale=*/0.0f, /*zero_point=*/0);
  quantization::Params<int8_t> weights_quant_params(/*scale=*/0.0f, /*zero_point=*/0);
  if (use_special_quantize_parameter) {
    input_quant_params.scale = 0.1f;
    weights_quant_params.scale = 0.1f;
    input_quant_params.zero_point = 128;
    weights_quant_params.zero_point = 1;
  }

  RunQAttention<uint8_t, int8_t, EP::CPU>(
      input_data, weights_data, bias_data, mask_index_data, output_data, input_quant_params, weights_quant_params,
      batch_size, sequence_length, hidden_size, number_of_heads, is_unidirectional, false, input_hidden_size);
}

static void RunQAttentionAll(
    const std::vector<float>& input_data,
    const std::vector<float>& weight_data,
    const std::vector<float>& bias_data,
    const std::vector<int32_t>& mask_index_data,
    const std::vector<float>& output_data,
    int batch_size,
    int sequence_length,
    int hidden_size,
    int number_of_heads,
    bool use_special_quantize_parameter = true,
    bool is_unidirectional = false,
    bool use_float16 = false,
    int input_hidden_size = 0) {
  RunQAttentionU8U8(input_data, weight_data, bias_data, mask_index_data, output_data,
                    batch_size, sequence_length, hidden_size, number_of_heads,
                    use_special_quantize_parameter, is_unidirectional, input_hidden_size);
  RunQAttentionU8S8(input_data, weight_data, bias_data, mask_index_data, output_data,
                    batch_size, sequence_length, hidden_size, number_of_heads,
                    use_special_quantize_parameter, is_unidirectional, input_hidden_size);
  RunQAttentionCUDA(input_data, weight_data, bias_data, mask_index_data, output_data,
                    batch_size, sequence_length, hidden_size, number_of_heads,
                    use_special_quantize_parameter, is_unidirectional, use_float16, input_hidden_size);
}

TEST(QAttentionTest, QAttentionBatch1) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.8f, -0.5f, 0.0f, 1.f,
      0.5f, 0.2f, 0.3f, -0.6f};

  std::vector<float> weight_data = {
      0.1f, -0.2f, 0.3f, 1.0f, 1.1f, 0.3f, 0.5f, 0.2f, 0.3f, -0.6f, 1.5f, 2.0f,
      0.5f, 0.1f, 0.4f, 1.6f, 1.0f, 2.0f, 0.4f, 0.8f, 0.9f, 0.1f, -1.3f, 0.7f,
      0.3f, 0.2f, 4.0f, 2.2f, 1.6f, 1.1f, 0.7f, 0.2f, 0.4f, 1.0f, 1.2f, 0.5f,
      0.2f, 0.1f, 0.4f, 1.6f, 2.4f, 3.3f, 2.1f, 4.2f, 8.4f, 0.0f, 2.1f, 3.2f};

  std::vector<float> bias_data = {
      -0.5f, 0.6f, 1.2f, 2.1f, 0.5f, 0.7f, 0.2f, 1.2f, 0.5f, 0.4f, 0.3f, 1.2f};

  std::vector<int32_t> mask_index_data = {2L};

  std::vector<float> output_data = {
      3.1495983600616455f, 0.10843668878078461f, 4.25f, 5.6499996185302734f,
      3.9696791172027588f, 0.073143675923347473f, 4.2499995231628418f, 5.6499991416931152f};

  RunQAttentionAll(input_data, weight_data, bias_data, mask_index_data, output_data,
                   batch_size, sequence_length, hidden_size, number_of_heads);
}

TEST(QAttentionTest, QAttentionBatch1_Float16) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.8f, -0.5f, 0.0f, 1.f,
      0.5f, 0.2f, 0.3f, -0.6f};

  std::vector<float> weight_data = {
      0.1f, -0.2f, 0.3f, 1.0f, 1.1f, 0.3f, 0.5f, 0.2f, 0.3f, -0.6f, 1.5f, 2.0f,
      0.5f, 0.1f, 0.4f, 1.6f, 1.0f, 2.0f, 0.4f, 0.8f, 0.9f, 0.1f, -1.3f, 0.7f,
      0.3f, 0.2f, 4.0f, 2.2f, 1.6f, 1.1f, 0.7f, 0.2f, 0.4f, 1.0f, 1.2f, 0.5f,
      0.2f, 0.1f, 0.4f, 1.6f, 2.4f, 3.3f, 2.1f, 4.2f, 8.4f, 0.0f, 2.1f, 3.2f};

  std::vector<float> bias_data = {
      -0.5f, 0.6f, 1.2f, 2.1f, 0.5f, 0.7f, 0.2f, 1.2f, 0.5f, 0.4f, 0.3f, 1.2f};

  std::vector<int32_t> mask_index_data = {2L};

  std::vector<float> output_data = {
      3.15039f, 0.1082763671875f, 4.24609375f, 5.6484375f,
      3.96679f, 0.072998046875f, 4.24609f, 5.6484375f};

  RunQAttentionCUDA(input_data, weight_data, bias_data, mask_index_data, output_data,
                    batch_size, sequence_length, hidden_size, number_of_heads,
                    true /*use_special_quantize_parameter*/,
                    false /*is_unidirectional*/,
                    true /*use_float16*/);
}

TEST(QAttentionTest, QAttentionBatch2) {
  int batch_size = 2;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.8f, -0.5f, 0.0f, 1.f,
      0.5f, 0.2f, 0.3f, -0.6f,
      0.8f, -0.5f, 0.0f, 1.f,
      0.5f, 0.2f, 0.3f, -0.6f};

  std::vector<float> weight_data = {
      0.1f, -0.2f, 0.3f, 1.0f, 1.1f, 0.3f, 0.5f, 0.2f, 0.3f, -0.6f, 1.5f, 2.0f,
      0.5f, 0.1f, 0.4f, 1.6f, 1.0f, 2.0f, 0.4f, 0.8f, 0.9f, 0.1f, -1.3f, 0.7f,
      0.3f, 0.2f, 4.0f, 2.2f, 1.6f, 1.1f, 0.7f, 0.2f, 0.4f, 1.0f, 1.2f, 0.5f,
      0.2f, 0.1f, 0.4f, 1.6f, 2.4f, 3.3f, 2.1f, 4.2f, 8.4f, 0.0f, 2.1f, 3.2f};

  std::vector<float> bias_data = {
      -0.5f, 0.6f, 1.2f, 2.1f, 0.5f, 0.7f, 0.2f, 1.2f, 0.5f, 0.4f, 0.3f, 1.2f};

  std::vector<int32_t> mask_index_data = {2L, 2L};

  std::vector<float> output_data = {
      3.1495983600616455f, 0.10843668878078461f, 4.25f, 5.6499996185302734f,
      3.9696791172027588f, 0.073143675923347473f, 4.2499995231628418f, 5.6499991416931152f,
      3.1495983600616455f, 0.10843668878078461f, 4.25f, 5.6499996185302734f,
      3.9696791172027588f, 0.073143675923347473f, 4.2499995231628418f, 5.6499991416931152f};

  RunQAttentionAll(input_data, weight_data, bias_data, mask_index_data, output_data,
                   batch_size, sequence_length, hidden_size, number_of_heads);
}

TEST(QAttentionTest, QAttentionMaskPartialSequence) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.8f, -0.5f, 0.0f, 1.f,
      0.5f, 0.2f, 0.3f, -0.6f};

  std::vector<float> weight_data = {
      0.1f, -0.2f, 0.3f, 1.0f, 1.1f, 0.3f, 0.5f, 0.2f, 0.3f, -0.6f, 1.5f, 2.0f,
      0.5f, 0.1f, 0.4f, 1.6f, 1.0f, 2.0f, 0.4f, 0.8f, 0.9f, 0.1f, -1.3f, 0.7f,
      0.3f, 0.2f, 4.0f, 2.2f, 1.6f, 1.1f, 0.7f, 0.2f, 0.4f, 1.0f, 1.2f, 0.5f,
      0.2f, 0.1f, 0.4f, 1.6f, 2.4f, 3.3f, 2.1f, 4.2f, 8.4f, 0.0f, 2.1f, 3.2f};

  std::vector<float> bias_data = {
      -0.5f, 0.6f, 1.2f, 2.1f, 0.5f, 0.7f, 0.2f, 1.2f, 0.5f, 0.4f, 0.3f, 1.2f};

  // Test mask_index < sequence_length
  std::vector<int32_t> mask_index_data = {1L};

  std::vector<float> output_data = {
      8.6899995803833008f, -0.13000002503395081f, 4.25f, 5.6499996185302734f,
      8.6899995803833008f, -0.13000002503395081f, 4.2499995231628418f, 5.6499991416931152f};

  RunQAttentionAll(input_data, weight_data, bias_data, mask_index_data, output_data,
                   batch_size, sequence_length, hidden_size, number_of_heads);
}

TEST(QAttentionTest, QAttentionMaskExceedSequence) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.8f, -0.5f, 0.0f, 1.f,
      0.5f, 0.2f, 0.3f, -0.6f};

  std::vector<float> weight_data = {
      0.1f, -0.2f, 0.3f, 1.0f, 1.1f, 0.3f, 0.5f, 0.2f, 0.3f, -0.6f, 1.5f, 2.0f,
      0.5f, 0.1f, 0.4f, 1.6f, 1.0f, 2.0f, 0.4f, 0.8f, 0.9f, 0.1f, -1.3f, 0.7f,
      0.3f, 0.2f, 4.0f, 2.2f, 1.6f, 1.1f, 0.7f, 0.2f, 0.4f, 1.0f, 1.2f, 0.5f,
      0.2f, 0.1f, 0.4f, 1.6f, 2.4f, 3.3f, 2.1f, 4.2f, 8.4f, 0.0f, 2.1f, 3.2f};

  std::vector<float> bias_data = {
      -0.5f, 0.6f, 1.2f, 2.1f, 0.5f, 0.7f, 0.2f, 1.2f, 0.5f, 0.4f, 0.3f, 1.2f};

  // Test mask_index > sequence_length
  std::vector<int32_t> mask_index_data = {3L};

  std::vector<float> output_data = {
      3.1495983600616455f, 0.10843668878078461f, 4.25f, 5.6499996185302734f,
      3.9696791172027588f, 0.073143675923347473f, 4.2499995231628418f, 5.6499991416931152f};

  RunQAttentionAll(input_data, weight_data, bias_data, mask_index_data, output_data,
                   batch_size, sequence_length, hidden_size, number_of_heads);
}

TEST(QAttentionTest, QAttentionNoMaskIndex) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.8f, -0.5f, 0.0f, 1.f,
      0.5f, 0.2f, 0.3f, -0.6f};

  std::vector<float> weight_data = {
      0.1f, -0.2f, 0.3f, 1.0f, 1.1f, 0.3f, 0.5f, 0.2f, 0.3f, -0.6f, 1.5f, 2.0f,
      0.5f, 0.1f, 0.4f, 1.6f, 1.0f, 2.0f, 0.4f, 0.8f, 0.9f, 0.1f, -1.3f, 0.7f,
      0.3f, 0.2f, 4.0f, 2.2f, 1.6f, 1.1f, 0.7f, 0.2f, 0.4f, 1.0f, 1.2f, 0.5f,
      0.2f, 0.1f, 0.4f, 1.6f, 2.4f, 3.3f, 2.1f, 4.2f, 8.4f, 0.0f, 2.1f, 3.2f};

  std::vector<float> bias_data = {
      -0.5f, 0.6f, 1.2f, 2.1f, 0.5f, 0.7f, 0.2f, 1.2f, 0.5f, 0.4f, 0.3f, 1.2f};

  // No mask_index
  std::vector<int32_t> mask_index_data = {};

  std::vector<float> output_data = {
      3.1495983600616455f, 0.10843668878078461f, 4.25f, 5.6499996185302734f,
      3.9696791172027588f, 0.073143675923347473f, 4.2499995231628418f, 5.6499991416931152f};

  RunQAttentionAll(input_data, weight_data, bias_data, mask_index_data, output_data,
                   batch_size, sequence_length, hidden_size, number_of_heads);
}

TEST(QAttentionTest, QAttentionUnidirectional_U8U8) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.91099896f, -0.18294459f, -0.36594841f, 0.28410032f,
      -0.12125026f, -0.66160089f, 0.38809127f, -0.22455512f};

  std::vector<float> weight_data = {
      -0.2659236192703247f,
      0.2789675071835518f,
      0.7280516624450684f,
      0.50951678305864334f,
      0.20417947322130203f,
      -0.4751841351389885f,
      0.43815530836582184f,
      0.6015353370457888f,
      -0.11496957391500473f,
      -0.1773347705602646f,
      0.30928605794906616f,
      0.5648412741720676f,

      0.8960387855768204f,
      -0.27270448207855225f,
      0.14847396314144135f,
      -0.17960812151432037f,
      0.1788954995572567f,
      0.9993876516819f,
      0.3943513706326485f,
      -0.2484400011599064f,
      -0.12958766520023346f,
      0.220433309674263f,
      0.1720484346151352f,
      0.22024005651474f,

      0.59368450194597244f,
      0.1710093915462494f,
      -0.3967452347278595f,
      -0.1591450721025467f,
      0.1446179747581482f,
      -0.20505407452583313f,
      0.12749597430229187f,
      0.32139700651168823f,
      0.139958456158638f,
      -0.10619817674160004f,
      0.4528557509183884f,
      0.45598603785037994f,

      -0.7152545265853405f,
      0.109454445540905f,
      -0.1582530289888382f,
      -0.2646341919898987f,
      0.920850858092308f,
      0.701494812965393f,
      -0.19062495231628418f,
      -0.24360455572605133f,
      -0.9368397295475006f,
      0.7878211885690689f,
      0.2973634898662567f,
      0.11210034042596817f};

  std::vector<float> bias_data = {
      -0.0540979839861393f,
      -0.06444740295410156f,
      0.03112877532839775f,
      -0.08288222551345825f,
      0.07840359210968018f,
      0.039143580943346024f,
      -0.45591455698013306f,
      -0.11876055598258972f,
      0.3670335114002228f,
      0.028461361303925514f,
      -0.08913630992174149f,
      0.28048714995384216f};

  // No mask_index
  std::vector<int32_t> mask_index_data = {};

  std::vector<float> output_data = {
      -0.027716159820556641f, 0.091021925210952759f,
      0.080938525497913361f, 0.61913836002349854f,
      0.36089283227920532f, -0.11653690040111542f,
      -0.030121456831693649f, 0.40923327207565308f};

  RunQAttentionU8U8(input_data, weight_data, bias_data, mask_index_data, output_data,
                    batch_size, sequence_length, hidden_size, number_of_heads,
                    false /*use_special_quantize_parameter*/,
                    true /*is_unidirectional*/);
}

TEST(QAttentionTest, QAttentionUnidirectional_U8S8) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.91099896f, -0.18294459f, -0.36594841f, 0.28410032f,
      -0.12125026f, -0.66160089f, 0.38809127f, -0.22455512f};

  std::vector<float> weight_data = {
      -0.2659236192703247f,
      0.2789675071835518f,
      0.7280516624450684f,
      0.50951678305864334f,
      0.20417947322130203f,
      -0.4751841351389885f,
      0.43815530836582184f,
      0.6015353370457888f,
      -0.11496957391500473f,
      -0.1773347705602646f,
      0.30928605794906616f,
      0.5648412741720676f,

      0.8960387855768204f,
      -0.27270448207855225f,
      0.14847396314144135f,
      -0.17960812151432037f,
      0.1788954995572567f,
      0.9993876516819f,
      0.3943513706326485f,
      -0.2484400011599064f,
      -0.12958766520023346f,
      0.220433309674263f,
      0.1720484346151352f,
      0.22024005651474f,

      0.59368450194597244f,
      0.1710093915462494f,
      -0.3967452347278595f,
      -0.1591450721025467f,
      0.1446179747581482f,
      -0.20505407452583313f,
      0.12749597430229187f,
      0.32139700651168823f,
      0.139958456158638f,
      -0.10619817674160004f,
      0.4528557509183884f,
      0.45598603785037994f,

      -0.7152545265853405f,
      0.109454445540905f,
      -0.1582530289888382f,
      -0.2646341919898987f,
      0.920850858092308f,
      0.701494812965393f,
      -0.19062495231628418f,
      -0.24360455572605133f,
      -0.9368397295475006f,
      0.7878211885690689f,
      0.2973634898662567f,
      0.11210034042596817f};

  std::vector<float> bias_data = {
      -0.0540979839861393f,
      -0.06444740295410156f,
      0.03112877532839775f,
      -0.08288222551345825f,
      0.07840359210968018f,
      0.039143580943346024f,
      -0.45591455698013306f,
      -0.11876055598258972f,
      0.3670335114002228f,
      0.028461361303925514f,
      -0.08913630992174149f,
      0.28048714995384216f};

  // No mask_index
  std::vector<int32_t> mask_index_data = {};

  std::vector<float> output_data = {
      -0.029270321130752563f, 0.089105717837810516f,
      0.084381766617298126f, 0.62047165632247925f,
      0.36089283227920532f, -0.11732138693332672f,
      -0.029981952160596848f, 0.40998253226280212f};

  RunQAttentionU8S8(input_data, weight_data, bias_data, mask_index_data, output_data,
                    batch_size, sequence_length, hidden_size, number_of_heads,
                    false /*use_special_quantize_parameter*/,
                    true /*is_unidirectional*/);
}

TEST(QAttentionTest, QAttentionUnidirectional_CUDA) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.91099896f, -0.18294459f, -0.36594841f, 0.28410032f,
      -0.12125026f, -0.66160089f, 0.38809127f, -0.22455512f};

  std::vector<float> weight_data = {
      -0.2659236192703247f,
      0.2789675071835518f,
      0.7280516624450684f,
      0.50951678305864334f,
      0.20417947322130203f,
      -0.4751841351389885f,
      0.43815530836582184f,
      0.6015353370457888f,
      -0.11496957391500473f,
      -0.1773347705602646f,
      0.30928605794906616f,
      0.5648412741720676f,

      0.8960387855768204f,
      -0.27270448207855225f,
      0.14847396314144135f,
      -0.17960812151432037f,
      0.1788954995572567f,
      0.9993876516819f,
      0.3943513706326485f,
      -0.2484400011599064f,
      -0.12958766520023346f,
      0.220433309674263f,
      0.1720484346151352f,
      0.22024005651474f,

      0.59368450194597244f,
      0.1710093915462494f,
      -0.3967452347278595f,
      -0.1591450721025467f,
      0.1446179747581482f,
      -0.20505407452583313f,
      0.12749597430229187f,
      0.32139700651168823f,
      0.139958456158638f,
      -0.10619817674160004f,
      0.4528557509183884f,
      0.45598603785037994f,

      -0.7152545265853405f,
      0.109454445540905f,
      -0.1582530289888382f,
      -0.2646341919898987f,
      0.920850858092308f,
      0.701494812965393f,
      -0.19062495231628418f,
      -0.24360455572605133f,
      -0.9368397295475006f,
      0.7878211885690689f,
      0.2973634898662567f,
      0.11210034042596817f};

  std::vector<float> bias_data = {
      -0.0540979839861393f,
      -0.06444740295410156f,
      0.03112877532839775f,
      -0.08288222551345825f,
      0.07840359210968018f,
      0.039143580943346024f,
      -0.45591455698013306f,
      -0.11876055598258972f,
      0.3670335114002228f,
      0.028461361303925514f,
      -0.08913630992174149f,
      0.28048714995384216f};

  // No mask_index
  std::vector<int32_t> mask_index_data = {};

  std::vector<float> output_data = {
      -0.037525445222854614f, 0.089105717837810516f,
      0.076988570392131805f, 0.62047165632247925f,
      0.36089283227920532f, -0.11732138693332672f,
      -0.029981952160596848f, 0.40998253226280212f};

  RunQAttentionCUDA(input_data, weight_data, bias_data, mask_index_data, output_data,
                    batch_size, sequence_length, hidden_size, number_of_heads,
                    false /*use_special_quantize_parameter*/,
                    true /*is_unidirectional*/);
}

template <typename InputT, typename WeightT>
void TestQuantizedAttentionPastState(int64_t batch,
                                     int64_t seq_len,
                                     int64_t past_seq_len,
                                     int64_t hidden_size,
                                     int64_t head_number,
                                     int64_t head_size,
                                     const std::string& reference_model,
                                     bool is_weight_constant,
                                     bool per_column = false) {
  // create rand inputs
  RandomValueGenerator random{};

  constexpr InputT input_min = std::numeric_limits<InputT>::min();
  constexpr InputT input_max = std::numeric_limits<InputT>::max();
  constexpr int32_t input_range = input_max - input_min;

  int64_t weight_scale_zp_size = per_column ? 3 * hidden_size : 1;

  InputT input_mean = (input_min + input_max) / 2 + 1;
  std::vector<InputT> input_zero_point{input_mean};

  std::vector<int64_t> input_dims{batch, seq_len, hidden_size};
  std::vector<InputT> input_data = random.Gaussian<InputT>(input_dims, input_mean, static_cast<InputT>(input_range / 6), input_min, input_max);

  constexpr WeightT weight_min = std::numeric_limits<WeightT>::min();
  constexpr WeightT weight_max = std::numeric_limits<WeightT>::max();
  constexpr int32_t weight_range = weight_max - weight_min;

  std::vector<WeightT> weight_zero_point(weight_scale_zp_size);
  for (auto& zp : weight_zero_point) {
    zp = static_cast<WeightT>(random.Uniform<int32_t>({1}, weight_min, weight_max)[0]);
  }

  WeightT weight_mean = (weight_min + weight_max) / 2 + 1;
  std::vector<int64_t> weight_dims{hidden_size, 3 * hidden_size};
  std::vector<WeightT> weight_data = random.Gaussian<WeightT>(weight_dims, weight_mean, static_cast<WeightT>(weight_range / 6), weight_min, weight_max);

  std::vector<int64_t> bias_dims{3 * hidden_size};
  std::vector<float> bias_data = random.Gaussian<float>(bias_dims, 0.0f, 0.3f);

  std::vector<float> input_scale{0.005f};
  std::vector<float> weight_scale(random.Uniform<float>({weight_scale_zp_size}, -0.01f, 0.01f));

  std::vector<int64_t> past_dims{2, batch, head_number, past_seq_len, head_size};
  std::vector<float> past_data = random.Gaussian<float>(past_dims, 0.0f, 0.3f);

  OpTester test(""QAttention"", 1, onnxruntime::kMSDomain);
  test.AddAttribute<int64_t>(""num_heads"", head_number);
  test.AddAttribute<int64_t>(""unidirectional"", 1);
  test.AddInput<InputT>(""input"", input_dims, input_data);
  test.AddInput<WeightT>(""weight"", weight_dims, weight_data, is_weight_constant);
  test.AddInput<float>(""bias"", bias_dims, bias_data);
  test.AddInput<float>(""input_scale"", {1}, input_scale);
  test.AddInput<float>(""weight_scale"", {weight_scale_zp_size}, weight_scale);
  test.AddOptionalInputEdge<int32_t>();
  test.AddInput<InputT>(""input_zero_point"", {1}, input_zero_point);
  test.AddInput<WeightT>(""weight_zero_point"", {weight_scale_zp_size}, weight_zero_point);
  test.AddInput<float>(""past"", past_dims, past_data);

  test.AddReferenceOutputs(reference_model);
  test.Run();
}

TEST(QAttentionTest, QAttentionPastState_u8u8) {
  TestQuantizedAttentionPastState<uint8_t, uint8_t>(2, 5, 15, 768, 12, 64,
                                                    ""testdata/attention_past_state.u8u8.onnx"",
                                                    false /*is_weight_constant*/);

  TestQuantizedAttentionPastState<uint8_t, uint8_t>(2, 5, 15, 768, 12, 64,
                                                    ""testdata/attention_past_state.u8u8.onnx"",
                                                    true /*is_weight_constant*/);

  TestQuantizedAttentionPastState<uint8_t, uint8_t>(2, 5, 15, 768, 12, 64,
                                                    ""testdata/attention_past_state.u8u8.onnx"",
                                                    false /*is_weight_constant*/,
                                                    true /*per_column*/);

  TestQuantizedAttentionPastState<uint8_t, uint8_t>(2, 5, 15, 768, 12, 64,
                                                    ""testdata/attention_past_state.u8u8.onnx"",
                                                    true /*is_weight_constant*/,
                                                    true /*per_column*/);
}

TEST(QAttentionTest, QAttentionPastState_u8s8) {
  TestQuantizedAttentionPastState<uint8_t, int8_t>(2, 5, 15, 768, 12, 64,
                                                   ""testdata/attention_past_state.u8s8.onnx"",
                                                   false /*is_weight_constant*/);

  TestQuantizedAttentionPastState<uint8_t, int8_t>(2, 5, 15, 768, 12, 64,
                                                   ""testdata/attention_past_state.u8s8.onnx"",
                                                   true /*is_weight_constant*/);

  TestQuantizedAttentionPastState<uint8_t, int8_t>(2, 5, 15, 768, 12, 64,
                                                   ""testdata/attention_past_state.u8s8.onnx"",
                                                   false /*is_weight_constant*/,
                                                   true /*per_column*/);

  TestQuantizedAttentionPastState<uint8_t, int8_t>(2, 5, 15, 768, 12, 64,
                                                   ""testdata/attention_past_state.u8s8.onnx"",
                                                   true /*is_weight_constant*/,
                                                   true /*per_column*/);
}

TEST(QAttentionTest, QAttentionPrunedModel) {
  int batch_size = 2;
  int sequence_length = 2;
  // test input_hidden_size > hidden_size
  int input_hidden_size = 6;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.5f, 0.2f, 0.3f, -0.6f, 0.0f, 1.0f,
      0.8f, -0.5f, 0.0f, 1.f, 2.0f, 3.0f,
      0.8f, -0.5f, 0.0f, 1.f, 4.0f, 5.0f,
      0.5f, 0.2f, 0.3f, -0.6f, 6.0f, 7.0f};

  std::vector<float> weight_data = {
      0.1f, -0.2f, 0.3f, 1.0f, 1.1f, 0.3f, 0.5f, 0.2f, 0.3f, -0.6f, 1.5f, 2.0f,
      0.5f, 0.1f, 0.4f, 1.6f, 1.0f, 2.0f, 0.4f, 0.8f, 0.9f, 0.1f, -1.3f, 0.7f,
      0.3f, 0.2f, 4.0f, 2.2f, 1.6f, 1.1f, 0.7f, 0.2f, 0.4f, 1.0f, 1.2f, 0.5f,
      0.2f, 0.1f, 0.4f, 1.6f, 2.4f, 3.3f, 2.1f, 4.2f, 8.4f, 0.0f, 2.1f, 3.2f,
      0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f,
      1.2f, 1.1f, 1.0f, 0.9f, 0.8f, 0.7f, 0.6f, 0.5f, 0.4f, 0.3f, 0.2f, 0.1f};

  std::vector<float> bias_data = {
      -0.5f, 0.6f, 1.2f, 2.1f, 0.5f, 0.7f, 0.2f, 1.2f, 0.5f, 0.4f, 0.3f, 1.2f};

  std::vector<int32_t> mask_data = {};

  std::vector<float> output_data = {
      11.689527f, 2.769937f, 7.05f, 8.35f,
      11.69f, 2.77f, 7.05f, 8.35f,
      14.276558f, 5.374159f, 9.65f, 10.95f,
      14.289073f, 5.370287f, 9.65f, 10.95f};

  bool use_special_quantize_parameter = true;
  bool is_unidirectional = false;
  bool use_float16 = false;
  RunQAttentionAll(input_data, weight_data, bias_data, mask_data, output_data,
                   batch_size, sequence_length, hidden_size, number_of_heads,
                   use_special_quantize_parameter, is_unidirectional, use_float16,
                   input_hidden_size);
}

#ifndef ENABLE_TRAINING  // Prepacking is enabled only on non-training builds
TEST(QAttentionTest, SharedPrepackedWeights) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.8f, -0.5f, 0.0f, 1.f,
      0.5f, 0.2f, 0.3f, -0.6f};

  std::vector<float> weight_data = {
      0.1f, -0.2f, 0.3f, 1.0f, 1.1f, 0.3f, 0.5f, 0.2f, 0.3f, -0.6f, 1.5f, 2.0f,
      0.5f, 0.1f, 0.4f, 1.6f, 1.0f, 2.0f, 0.4f, 0.8f, 0.9f, 0.1f, -1.3f, 0.7f,
      0.3f, 0.2f, 4.0f, 2.2f, 1.6f, 1.1f, 0.7f, 0.2f, 0.4f, 1.0f, 1.2f, 0.5f,
      0.2f, 0.1f, 0.4f, 1.6f, 2.4f, 3.3f, 2.1f, 4.2f, 8.4f, 0.0f, 2.1f, 3.2f};

  std::vector<float> bias_data = {
      -0.5f, 0.6f, 1.2f, 2.1f, 0.5f, 0.7f, 0.2f, 1.2f, 0.5f, 0.4f, 0.3f, 1.2f};

  std::vector<int32_t> mask_index_data = {2L};

  std::vector<float> output_data = {
      3.1495983600616455f, 0.10843668878078461f, 4.25f, 5.6499996185302734f,
      3.9696791172027588f, 0.073143675923347473f, 4.2499995231628418f, 5.6499991416931152f};

  std::vector<int64_t> input_dims = {batch_size, sequence_length, hidden_size};
  std::vector<int64_t> weights_dims = {hidden_size, 3 * hidden_size};
  std::vector<int64_t> bias_dims = {3 * hidden_size};
  std::vector<int64_t> mask_index_dims = {batch_size};
  std::vector<int64_t> output_dims = {batch_size, sequence_length, hidden_size};

  OpTester tester(""QAttention"", 1, onnxruntime::kMSDomain);
  tester.AddAttribute<int64_t>(""num_heads"", static_cast<int64_t>(number_of_heads));

  tester.AddInput<uint8_t>(
      ""input"",
      input_dims,
      QuantizeTestVector<uint8_t>(
          input_data,
          quantization::Params<uint8_t>(/*scale=*/0.1f, /*zero_point=*/128)));

  auto weight_data_converted_to_int = QuantizeTestVector<uint8_t>(
      weight_data,
      quantization::Params<uint8_t>(/*scale=*/0.1f, /*zero_point=*/128));
  tester.AddInput<uint8_t>(""weight"",
                           weights_dims,
                           weight_data_converted_to_int,
                           /*is_initializer=*/true);  // Trigger pre-packing

  tester.AddInput<float>(""bias"", bias_dims, bias_data);
  tester.AddInput<float>(""input_scale"", {1}, {0.1f});
  tester.AddInput<float>(""weight_scale"", {1}, {0.1f});
  tester.AddOutput<float>(""output"", output_dims, output_data);

  tester.AddInput<int32_t>(""mask_index"", mask_index_dims, mask_index_data);

  tester.AddInput<uint8_t>(""input_zero_point"", {1}, {128});
  tester.AddInput<uint8_t>(""weight_zero_point"", {1}, {128});

  auto p_tensor = std::make_unique<Tensor>(DataTypeImpl::GetType<uint8_t>(), TensorShape(weights_dims),
                                           weight_data_converted_to_int.data(),
                                           OrtMemoryInfo(CPU, OrtAllocatorType::OrtDeviceAllocator));
  OrtValue weight;

  weight.Init(p_tensor.release(), DataTypeImpl::GetType<Tensor>(),
              DataTypeImpl::GetType<Tensor>()->GetDeleteFunc());

  SessionOptions so;

  // Set up weight as a shared initializer to be shared between sessions
  ASSERT_EQ(so.AddInitializer(""weight"", &weight), Status::OK());

  // We want all sessions running using this OpTester to be able to share pre-packed weights if applicable
  tester.EnableSharingOfPrePackedWeightsAcrossSessions();

  // Pre-packing is limited just to the CPU EP for now and we will only test the CPU EP
  // and we want to ensure that it is available in this build
  auto cpu_ep = []() -> std::vector<std::unique_ptr<IExecutionProvider>> {
    std::vector<std::unique_ptr<IExecutionProvider>> execution_providers;
    execution_providers.push_back(DefaultCpuExecutionProvider());
    return execution_providers;
  };

  size_t number_of_pre_packed_weights_counter_session_1 = 0;
  size_t number_of_shared_pre_packed_weights_counter = 0;

  // Session 1
  {
    auto ep_vec = cpu_ep();
    tester.Run(so, OpTester::ExpectResult::kExpectSuccess, """", {}, nullptr,
               &ep_vec, {}, &number_of_pre_packed_weights_counter_session_1, &number_of_shared_pre_packed_weights_counter);
    // Assert that no pre-packed weights have been shared thus far
    ASSERT_EQ(number_of_shared_pre_packed_weights_counter, static_cast<size_t>(0));
  }

  auto number_of_elements_in_shared_prepacked_buffers_container =
      tester.GetNumPrePackedWeightsShared();
  // Assert that the number of elements in the shared container
  // is the same as the number of weights that have been pre-packed
  ASSERT_EQ(number_of_pre_packed_weights_counter_session_1, number_of_elements_in_shared_prepacked_buffers_container);

  // On some platforms/architectures MLAS may choose to not do any pre-packing and the number of elements
  // that have been pre-packed will be zero in which case we do not continue with the testing
  // of ""sharing"" of pre-packed weights as there are no pre-packed weights to be shared at all.
  if (number_of_pre_packed_weights_counter_session_1 == 0)
    return;

  // Session 2
  {
    size_t number_of_pre_packed_weights_counter_session_2 = 0;
    auto ep_vec = cpu_ep();
    tester.Run(so, OpTester::ExpectResult::kExpectSuccess, """", {}, nullptr,
               &ep_vec, {}, &number_of_pre_packed_weights_counter_session_2, &number_of_shared_pre_packed_weights_counter);

    // Assert that the same number of weights were pre-packed in both sessions
    ASSERT_EQ(number_of_pre_packed_weights_counter_session_1, number_of_pre_packed_weights_counter_session_2);

    // Assert that the number of pre-packed weights that were shared equals
    // the number of pre-packed weights in the second session
    ASSERT_EQ(number_of_pre_packed_weights_counter_session_2,
              static_cast<size_t>(number_of_shared_pre_packed_weights_counter));
  }
}
#endif

}  // namespace test
}  // namespace onnxruntime
",16296,True,3747.4711060642308,median
"---
title: Appendix C. Resources on the Internet
part: Part V. Appendices
prev: books/handbook/bibliography
next: books/handbook/pgpkeys
---

[appendix]
[[eresources]]
= Resources on the Internet
:doctype: book
:icons: font
:sectnums!:
:source-highlighter: rouge
:experimental:
:skip-front-matter:
:figure-caption: Figure
:xrefstyle: basic
:relfileprefix: ../
:outfilesuffix:

include::share/mirrors.adoc[]
include::share/authors.adoc[]
include::share/releases.adoc[]
include::share/en/mailing-lists.adoc[]
include::share/en/teams.adoc[]
include::share/en/urls.adoc[]

[.title]
== Resources on the Internet

The rapid pace of FreeBSD progress makes print media impractical as a means of following the latest developments. Electronic resources are the best, if not often the only, way to stay informed of the latest advances. Since FreeBSD is a volunteer effort, the user community itself also generally serves as a ""technical support department"" of sorts, with electronic mail, web forums, and USENET news being the most effective way of reaching that community.

The most important points of contact with the FreeBSD user community are outlined below. Please send other resources not mentioned here to the {freebsd-doc} so that they may also be included.

[[eresources-www]]
[.title]
== Websites

* https://forums.FreeBSD.org/[The FreeBSD Forums] provide a web based discussion forum for FreeBSD questions and technical discussion.
* The http://www.youtube.com/bsdconferences[BSDConferences YouTube Channel] provides a collection of high quality videos from BSD conferences around the world. This is a great way to watch key developers give presentations about new work in FreeBSD.

[[eresources-mail]]
[.title]
== Mailing Lists

The mailing lists are the most direct way of addressing questions or opening a technical discussion to a concentrated FreeBSD audience. There are a wide variety of lists on a number of different FreeBSD topics. Sending questions to the most appropriate mailing list will invariably assure a faster and more accurate response.

The charters for the various lists are given at the bottom of this document. _Please read the charter before joining or sending mail to any list_. Most list subscribers receive many hundreds of FreeBSD related messages every day, and the charters and rules for use are meant to keep the signal-to-noise ratio of the lists high. To do less would see the mailing lists ultimately fail as an effective communications medium for the Project.

[.note]
====
[.admontitle]*Note:* +

_To test the ability to send email to FreeBSD lists, send a test message to {freebsd-test}._ Please do not send test messages to any other list.
====

When in doubt about what list to post a question to, see link:{freebsd-questions}[How to get best results from the FreeBSD-questions mailing list].

Before posting to any list, please learn about how to best use the mailing lists, such as how to help avoid frequently-repeated discussions, by reading the link:{mailing-list-faq}[Mailing List Frequently Asked Questions] (FAQ) document.

Archives are kept for all of the mailing lists and can be searched using the https://www.FreeBSD.org/search/[FreeBSD World Wide Web server]. The keyword searchable archive offers an excellent way of finding answers to frequently asked questions and should be consulted before posting a question. Note that this also means that messages sent to FreeBSD mailing lists are archived in perpetuity. When protecting privacy is a concern, consider using a disposable secondary email address and posting only public information.

[[eresources-summary]]
[.title]
=== List Summary

_General lists:_ The following are general lists which anyone is free (and encouraged) to join:

[.informaltable]
[cols=""20%,80%"", frame=""none"", options=""header""]
|===
| List
| Purpose


|link:{freebsd-advocacy-url}[freebsd-advocacy]
|FreeBSD Evangelism

|link:{freebsd-announce-url}[freebsd-announce]
|Important events and Project milestones (moderated)

|link:{freebsd-arch-url}[freebsd-arch]
|Architecture and design discussions

|link:{freebsd-bugbusters-url}[freebsd-bugbusters]
|Discussions pertaining to the maintenance of the FreeBSD problem report database and related tools

|link:{freebsd-bugs-url}[freebsd-bugs]
|Bug reports

|link:{freebsd-chat-url}[freebsd-chat]
|Non-technical items related to the FreeBSD community

|link:{freebsd-chromium-url}[freebsd-chromium]
|FreeBSD-specific Chromium issues

|link:{freebsd-current-url}[freebsd-current]
|Discussion concerning the use of FreeBSD-CURRENT

|link:{freebsd-isp-url}[freebsd-isp]
|Issues for Internet Service Providers using FreeBSD

|link:{freebsd-jobs-url}[freebsd-jobs]
|FreeBSD employment and consulting opportunities

|link:{freebsd-quarterly-calls-url}[freebsd-quarterly-calls]
|Calls for quarterly status reports (moderated)

|link:{freebsd-questions-url}[freebsd-questions]
|User questions and technical support

|link:{freebsd-security-notifications-url}[freebsd-security-notifications]
|Security notifications (moderated)

|link:{freebsd-stable-url}[freebsd-stable]
|Discussion concerning the use of FreeBSD-STABLE

|link:{freebsd-test-url}[freebsd-test]
|Where to send test messages instead of to one of the actual lists

|link:{freebsd-women-url}[freebsd-women]
|FreeBSD advocacy for women
|===

_Technical lists:_ The following lists are for technical discussion. Read the charter for each list carefully before joining or sending mail to one as there are firm guidelines for their use and content.

[.informaltable]
[cols=""20%,80%"", frame=""none"", options=""header""]
|===
| List
| Purpose


|link:{freebsd-acpi-url}[freebsd-acpi]
|ACPI and power management development

|link:{freebsd-amd64-url}[freebsd-amd64]
|Porting FreeBSD to AMD64 systems (moderated)

|link:{freebsd-apache-url}[freebsd-apache]
|Discussion about Apache related ports

|link:{freebsd-arm-url}[freebsd-arm]
|Porting FreeBSD to ARM(R) processors

|link:{freebsd-atm-url}[freebsd-atm]
|Using ATM networking with FreeBSD

|link:{freebsd-bluetooth-url}[freebsd-bluetooth]
|Using Bluetooth(R) technology in FreeBSD

|link:{freebsd-cloud-url}[freebsd-cloud]
|FreeBSD on cloud platforms (EC2, GCE, Azure, etc.)

|link:{freebsd-cluster-url}[freebsd-cluster]
|Using FreeBSD in a clustered environment

|link:{freebsd-database-url}[freebsd-database]
|Discussing database use and development under FreeBSD

|link:{freebsd-desktop-url}[freebsd-desktop]
|Using and improving FreeBSD on the desktop

|link:{dev-ci-url}[dev-ci]
|Build and test reports from the Continuous Integration servers

|link:{dev-reviews-url}[dev-reviews]
|Notifications of the FreeBSD review system

|link:{freebsd-doc-url}[freebsd-doc]
|Creating FreeBSD related documents

|link:{freebsd-drivers-url}[freebsd-drivers]
|Writing device drivers for FreeBSD

|link:{freebsd-dtrace-url}[freebsd-dtrace]
|Using and working on DTrace in FreeBSD

|link:{freebsd-eclipse-url}[freebsd-eclipse]
|FreeBSD users of Eclipse IDE, tools, rich client applications and ports.

|link:{freebsd-elastic-url}[freebsd-elastic]
|FreeBSD-specific ElasticSearch discussions

|link:{freebsd-embedded-url}[freebsd-embedded]
|Using FreeBSD in embedded applications

|link:{freebsd-eol-url}[freebsd-eol]
|Peer support of FreeBSD-related software that is no longer supported by the FreeBSD Project.

|link:{freebsd-emulation-url}[freebsd-emulation]
|Emulation of other systems such as Linux/MS-DOS(R)/Windows(R)

|link:{freebsd-enlightenment-url}[freebsd-enlightenment]
|Porting Enlightenment and Enlightenment applications

|link:{freebsd-erlang-url}[freebsd-erlang]
|FreeBSD-specific Erlang discussions

|link:{freebsd-firewire-url}[freebsd-firewire]
|FreeBSD FireWire(R) (iLink, IEEE 1394) technical discussion

|link:{freebsd-fortran-url}[freebsd-fortran]
|Fortran on FreeBSD

|link:{freebsd-fs-url}[freebsd-fs]
|File systems

|link:{freebsd-games-url}[freebsd-games]
|Support for Games on FreeBSD

|link:{freebsd-gecko-url}[freebsd-gecko]
|Gecko Rendering Engine issues

|link:{freebsd-geom-url}[freebsd-geom]
|GEOM-specific discussions and implementations

|link:{freebsd-git-url}[freebsd-git]
|Discussion of git use in the FreeBSD project

|link:{freebsd-gnome-url}[freebsd-gnome]
|Porting GNOME and GNOME applications

|link:{freebsd-hackers-url}[freebsd-hackers]
|General technical discussion

|link:{freebsd-haskell-url}[freebsd-haskell]
|FreeBSD-specific Haskell issues and discussions

|link:{freebsd-hardware-url}[freebsd-hardware]
|General discussion of hardware for running FreeBSD

|link:{freebsd-i18n-url}[freebsd-i18n]
|FreeBSD Internationalization

|link:{freebsd-infiniband-url}[freebsd-infiniband]
|Infiniband on FreeBSD

|link:{freebsd-ipfw-url}[freebsd-ipfw]
|Technical discussion concerning the redesign of the IP firewall code

|link:{freebsd-isdn-url}[freebsd-isdn]
|ISDN developers

|link:{freebsd-jail-url}[freebsd-jail]
|Discussion about the man:jail[8] facility

|link:{freebsd-java-url}[freebsd-java]
|Java(TM) developers and people porting JDK(TM)s to FreeBSD

|link:{freebsd-kde-url}[freebsd-kde]
|Porting KDE and KDE applications

|link:{freebsd-lfs-url}[freebsd-lfs]
|Porting LFS to FreeBSD

|link:{freebsd-mips-url}[freebsd-mips]
|Porting FreeBSD to MIPS(R)

|link:{freebsd-mono-url}[freebsd-mono]
|Mono and C# applications on FreeBSD

|link:{freebsd-multimedia-url}[freebsd-multimedia]
|Multimedia applications

|link:{freebsd-new-bus-url}[freebsd-new-bus]
|Technical discussions about bus architecture

|link:{freebsd-net-url}[freebsd-net]
|Networking discussion and TCP/IP source code

|link:{freebsd-numerics-url}[freebsd-numerics]
|Discussions of high quality implementation of libm functions

|link:{freebsd-ocaml-url}[freebsd-ocaml]
|FreeBSD-specific OCaml discussions

|link:{freebsd-office-url}[freebsd-office]
|Office applications on FreeBSD

|link:{freebsd-performance-url}[freebsd-performance]
|Performance tuning questions for high performance/load installations

|link:{freebsd-perl-url}[freebsd-perl]
|Maintenance of a number of Perl-related ports

|link:{freebsd-pf-url}[freebsd-pf]
|Discussion and questions about the packet filter firewall system

|link:{freebsd-pkg-url}[freebsd-pkg]
|Binary package management and package tools discussion

|link:{freebsd-pkg-fallout-url}[freebsd-pkg-fallout]
|Fallout logs from package building

|link:{freebsd-pkgbase-url}[freebsd-pkgbase]
|Packaging the FreeBSD base system

|link:{freebsd-platforms-url}[freebsd-platforms]
|Concerning ports to non Intel(R) architecture platforms

|link:{freebsd-ports-url}[freebsd-ports]
|Discussion of the Ports Collection

|link:{freebsd-ports-announce-url}[freebsd-ports-announce]
|Important news and instructions about the Ports Collection (moderated)

|link:{freebsd-ports-bugs-url}[freebsd-ports-bugs]
|Discussion of the ports bugs/PRs

|link:{freebsd-ppc-url}[freebsd-ppc]
|Porting FreeBSD to the PowerPC(R)

|link:{freebsd-proliant-url}[freebsd-proliant]
|Technical discussion of FreeBSD on HP ProLiant server platforms

|link:{freebsd-python-url}[freebsd-python]
|FreeBSD-specific Python issues

|link:{freebsd-rc-url}[freebsd-rc]
|Discussion related to the [.filename]#rc.d# system and its development

|link:{freebsd-realtime-url}[freebsd-realtime]
|Development of realtime extensions to FreeBSD

|link:{freebsd-ruby-url}[freebsd-ruby]
|FreeBSD-specific Ruby discussions

|link:{freebsd-scsi-url}[freebsd-scsi]
|The SCSI subsystem

|link:{freebsd-security-url}[freebsd-security]
|Security issues affecting FreeBSD

|link:{freebsd-snapshots-url}[freebsd-snapshots]
|FreeBSD Development Snapshot Announcements

|link:{freebsd-sparc64-url}[freebsd-sparc64]
|Porting FreeBSD to SPARC(R) based systems

|link:{freebsd-standards-url}[freebsd-standards]
|FreeBSD's conformance to the C99 and the POSIX(R) standards

|link:{freebsd-sysinstall-url}[freebsd-sysinstall]
|man:sysinstall[8] development

|link:{freebsd-tcltk-url}[freebsd-tcltk]
|FreeBSD-specific Tcl/Tk discussions

|link:{freebsd-testing-url}[freebsd-testing]
|Testing on FreeBSD

|link:{freebsd-tex-url}[freebsd-tex]
|Porting TeX and its applications to FreeBSD

|link:{freebsd-threads-url}[freebsd-threads]
|Threading in FreeBSD

|link:{freebsd-tilera-url}[freebsd-tilera]
|Porting FreeBSD to the Tilera family of CPUs

|link:{freebsd-tokenring-url}[freebsd-tokenring]
|Support Token Ring in FreeBSD

|link:{freebsd-toolchain-url}[freebsd-toolchain]
|Maintenance of FreeBSD's integrated toolchain

|link:{freebsd-translators-url}[freebsd-translators]
|Translating FreeBSD documents and programs

|link:{freebsd-transport-url}[freebsd-transport]
|Discussions of transport level network protocols in FreeBSD

|link:{freebsd-usb-url}[freebsd-usb]
|Discussing FreeBSD support for USB

|link:{freebsd-virtualization-url}[freebsd-virtualization]
|Discussion of various virtualization techniques supported by FreeBSD

|link:{freebsd-vuxml-url}[freebsd-vuxml]
|Discussion on VuXML infrastructure

|link:{freebsd-x11-url}[freebsd-x11]
|Maintenance and support of X11 on FreeBSD

|link:{freebsd-xen-url}[freebsd-xen]
|Discussion of the FreeBSD port to Xen(TM) - implementation and usage

|link:{freebsd-xfce-url}[freebsd-xfce]
|XFCE for FreeBSD - porting and maintaining

|link:{freebsd-zope-url}[freebsd-zope]
|Zope for FreeBSD - porting and maintaining
|===

_Limited lists:_ The following lists are for more specialized (and demanding) audiences and are probably not of interest to the general public. It is also a good idea to establish a presence in the technical lists before joining one of these limited lists in order to understand the communications etiquette involved.

[.informaltable]
[cols=""20%,80%"", frame=""none"", options=""header""]
|===
| List
| Purpose


|link:{freebsd-hubs-url}[freebsd-hubs]
|People running mirror sites (infrastructural support)

|link:{freebsd-user-groups-url}[freebsd-user-groups]
|User group coordination

|link:{freebsd-wip-status-url}[freebsd-wip-status]
|FreeBSD Work-In-Progress Status

|link:{freebsd-wireless-url}[freebsd-wireless]
|Discussions of 802.11 stack, tools, device driver development
|===

_Digest lists:_ All of the above lists are available in a digest format. Once subscribed to a list, the digest options can be changed in the account options section.

_SVN lists:_ The following lists are for people interested in seeing the log messages for changes to various areas of the source tree. They are _Read-Only_ lists and should not have mail sent to them.

[.informaltable]
[cols=""20%,20%,60%"", frame=""none"", options=""header""]
|===
| List
| Source area
| Area Description (source for)


|link:{svn-doc-all-url}[svn-doc-all]
|[.filename]#/usr/doc#
|All changes to the doc Subversion repository (except for [.filename]#user#, [.filename]#projects# and [.filename]#translations#)

|link:{svn-doc-head-url}[svn-doc-head]
|[.filename]#/usr/doc#
|All changes to the ""head"" branch of the doc Subversion repository

|link:{svn-doc-projects-url}[svn-doc-projects]
|[.filename]#/usr/doc/projects#
|All changes to the [.filename]#projects# area of the doc Subversion repository

|link:{svn-doc-svnadmin-url}[svn-doc-svnadmin]
|[.filename]#/usr/doc#
|All changes to the administrative scripts, hooks, and other configuration data of the doc Subversion repository

|link:{svn-ports-all-url}[svn-ports-all]
|[.filename]#/usr/ports#
|All changes to the ports Subversion repository

|link:{svn-ports-head-url}[svn-ports-head]
|[.filename]#/usr/ports#
|All changes to the ""head"" branch of the ports Subversion repository

|link:{svn-ports-svnadmin-url}[svn-ports-svnadmin]
|[.filename]#/usr/ports#
|All changes to the administrative scripts, hooks, and other configuration data of the ports Subversion repository

|link:{svn-src-all-url}[svn-src-all]
|[.filename]#/usr/src#
|All changes to the src Subversion repository (except for [.filename]#user# and [.filename]#projects#)

|link:{svn-src-head-url}[svn-src-head]
|[.filename]#/usr/src#
|All changes to the ""head"" branch of the src Subversion repository (the FreeBSD-CURRENT branch)

|link:{svn-src-projects-url}[svn-src-projects]
|[.filename]#/usr/projects#
|All changes to the [.filename]#projects# area of the src Subversion repository

|link:{svn-src-release-url}[svn-src-release]
|[.filename]#/usr/src#
|All changes to the [.filename]#releases# area of the src Subversion repository

|link:{svn-src-releng-url}[svn-src-releng]
|[.filename]#/usr/src#
|All changes to the [.filename]#releng# branches of the src Subversion repository (the security / release engineering branches)

|link:{svn-src-stable-url}[svn-src-stable]
|[.filename]#/usr/src#
|All changes to the all stable branches of the src Subversion repository

|link:{svn-src-stable-6-url}[svn-src-stable-6]
|[.filename]#/usr/src#
|All changes to the [.filename]#stable/6# branch of the src Subversion repository

|link:{svn-src-stable-7-url}[svn-src-stable-7]
|[.filename]#/usr/src#
|All changes to the [.filename]#stable/7# branch of the src Subversion repository

|link:{svn-src-stable-8-url}[svn-src-stable-8]
|[.filename]#/usr/src#
|All changes to the [.filename]#stable/8# branch of the src Subversion repository

|link:{svn-src-stable-9-url}[svn-src-stable-9]
|[.filename]#/usr/src#
|All changes to the [.filename]#stable/9# branch of the src Subversion repository

|link:{svn-src-stable-10-url}[svn-src-stable-10]
|[.filename]#/usr/src#
|All changes to the [.filename]#stable/10# branch of the src Subversion repository

|link:{svn-src-stable-11-url}[svn-src-stable-11]
|[.filename]#/usr/src#
|All changes to the [.filename]#stable/11# branch of the src Subversion repository

|link:{svn-src-stable-12-url}[svn-src-stable-12]
|[.filename]#/usr/src#
|All changes to the [.filename]#stable/12# branch of the src Subversion repository

|link:{svn-src-stable-other-url}[svn-src-stable-other]
|[.filename]#/usr/src#
|All changes to the older [.filename]#stable# branches of the src Subversion repository

|link:{svn-src-svnadmin-url}[svn-src-svnadmin]
|[.filename]#/usr/src#
|All changes to the administrative scripts, hooks, and other configuration data of the src Subversion repository

|link:{svn-src-user-url}[svn-src-user]
|[.filename]#/usr/src#
|All changes to the experimental [.filename]#user# area of the src Subversion repository

|link:{svn-src-vendor-url}[svn-src-vendor]
|[.filename]#/usr/src#
|All changes to the vendor work area of the src Subversion repository
|===

[[eresources-subscribe]]
[.title]
=== How to Subscribe

To subscribe to a list, click the list name at {mailman-lists-url}. The page that is displayed should contain all of the necessary subscription instructions for that list.

To actually post to a given list, send mail to mailto:listname@FreeBSD.org[listname@FreeBSD.org]. It will then be redistributed to mailing list members world-wide.

To unsubscribe from a list, click on the URL found at the bottom of every email received from the list. It is also possible to send an email to mailto:listname-unsubscribe@FreeBSD.org[listname-unsubscribe@FreeBSD.org] to unsubscribe.

It is important to keep discussion in the technical mailing lists on a technical track. To only receive important announcements, instead join the {freebsd-announce}, which is intended for infrequent traffic.

[[eresources-charters]]
[.title]
=== List Charters

_All_ FreeBSD mailing lists have certain basic rules which must be adhered to by anyone using them. Failure to comply with these guidelines will result in two (2) written warnings from the FreeBSD Postmaster mailto:postmaster@FreeBSD.org[postmaster@FreeBSD.org], after which, on a third offense, the poster will removed from all FreeBSD mailing lists and filtered from further posting to them. We regret that such rules and measures are necessary at all, but today's Internet is a pretty harsh environment, it would seem, and many fail to appreciate just how fragile some of its mechanisms are.

Rules of the road:

* The topic of any posting should adhere to the basic charter of the list it is posted to. If the list is about technical issues, the posting should contain technical discussion. Ongoing irrelevant chatter or flaming only detracts from the value of the mailing list for everyone on it and will not be tolerated. For free-form discussion on no particular topic, the {freebsd-chat} is freely available and should be used instead.
* No posting should be made to more than 2 mailing lists, and only to 2 when a clear and obvious need to post to both lists exists. For most lists, there is already a great deal of subscriber overlap and except for the most esoteric mixes (say ""-stable & -scsi""), there really is no reason to post to more than one list at a time. If a message is received with multiple mailing lists on the `Cc` line, trim the `Cc` line before replying. _The person who replies is still responsible for cross-posting, no matter who the originator might have been._
* Personal attacks and profanity (in the context of an argument) are not allowed, and that includes users and developers alike. Gross breaches of netiquette, like excerpting or reposting private mail when permission to do so was not and would not be forthcoming, are frowned upon but not specifically enforced. _However_, there are also very few cases where such content would fit within the charter of a list and it would therefore probably rate a warning (or ban) on that basis alone.
* Advertising of non-FreeBSD related products or services is strictly prohibited and will result in an immediate ban if it is clear that the offender is advertising by spam.

_Individual list charters:_

link:{freebsd-acpi-url}[freebsd-acpi]::
_ACPI and power management development_

link:{freebsd-announce-url}[freebsd-announce]::
_Important events / milestones_
+
This is the mailing list for people interested only in occasional announcements of significant FreeBSD events. This includes announcements about snapshots and other releases. It contains announcements of new FreeBSD capabilities. It may contain calls for volunteers etc. This is a low volume, strictly moderated mailing list.

link:{freebsd-arch-url}[freebsd-arch]::
_Architecture and design discussions_
+
This list is for discussion of the FreeBSD architecture. Messages will mostly be kept strictly technical in nature. Examples of suitable topics are:

** How to re-vamp the build system to have several customized builds running at the same time.
** What needs to be fixed with VFS to make Heidemann layers work.
** How do we change the device driver interface to be able to use the same drivers cleanly on many buses and architectures.
** How to write a network driver.

link:{freebsd-bluetooth-url}[freebsd-bluetooth]::
_Bluetooth(R) in FreeBSD_
+
This is the forum where FreeBSD's Bluetooth(R) users congregate. Design issues, implementation details, patches, bug reports, status reports, feature requests, and all matters related to Bluetooth(R) are fair game.

link:{freebsd-bugbusters-url}[freebsd-bugbusters]::
_Coordination of the Problem Report handling effort_
+
The purpose of this list is to serve as a coordination and discussion forum for the Bugmeister, his Bugbusters, and any other parties who have a genuine interest in the PR database. This list is not for discussions about specific bugs, patches or PRs.

link:{freebsd-bugs-url}[freebsd-bugs]::
_Bug reports_
+
This is the mailing list for reporting bugs in FreeBSD. Whenever possible, bugs should be submitted using the https://bugs.freebsd.org/bugzilla/enter_bug.cgi[web interface] to it.

link:{freebsd-chat-url}[freebsd-chat]::
_Non technical items related to the FreeBSD community_
+
This list contains the overflow from the other lists about non-technical, social information. It includes discussion about whether Jordan looks like a toon ferret or not, whether or not to type in capitals, who is drinking too much coffee, where the best beer is brewed, who is brewing beer in their basement, and so on. Occasional announcements of important events (such as upcoming parties, weddings, births, new jobs, etc) can be made to the technical lists, but the follow ups should be directed to this -chat list.

link:{freebsd-chromium-url}[freebsd-chromium]::
_FreeBSD-specific Chromium issues_
+
This is a list for the discussion of Chromium support for FreeBSD. This is a technical list to discuss development and installation of Chromium.

link:{freebsd-cloud-url}[freebsd-cloud]::
_Running FreeBSD on various cloud platforms_
+
This list discusses running FreeBSD on Amazon EC2, Google Compute Engine, Microsoft Azure, and other cloud computing platforms.

_FreeBSD core team_::
This is an internal mailing list for use by the core members. Messages can be sent to it when a serious FreeBSD-related matter requires arbitration or high-level scrutiny.

link:{freebsd-current-url}[freebsd-current]::
_Discussions about the use of FreeBSD-CURRENT_
+
This is the mailing list for users of FreeBSD-CURRENT. It includes warnings about new features coming out in -CURRENT that will affect the users, and instructions on steps that must be taken to remain -CURRENT. Anyone running ""CURRENT"" must subscribe to this list. This is a technical mailing list for which strictly technical content is expected.

link:{freebsd-desktop-url}[freebsd-desktop]::
_Using and improving FreeBSD on the desktop_
+
This is a forum for discussion of FreeBSD on the desktop. It is primarily a place for desktop porters and users to discuss issues and improve FreeBSD's desktop support.

link:{dev-ci-url}[dev-ci]::
_Continuous Integration reports of build and test results_
+
All Continuous Integration reports of build and test results

link:{dev-reviews-url}[dev-reviews]::
_Notifications of work in progress in FreeBSD's review tool_
+
Automated notifications of work in progress for review in FreeBSD's review tools, including patches.

link:{freebsd-doc-url}[freebsd-doc]::
_Documentation Project_
+
This mailing list is for the discussion of issues and projects related to the creation of documentation for FreeBSD. The members of this mailing list are collectively referred to as ""The FreeBSD Documentation Project"". It is an open list; feel free to join and contribute!

link:{freebsd-drivers-url}[freebsd-drivers]::
_Writing device drivers for FreeBSD_
+
This is a forum for technical discussions related to device drivers on FreeBSD. It is primarily a place for device driver writers to ask questions about how to write device drivers using the APIs in the FreeBSD kernel.

link:{freebsd-dtrace-url}[freebsd-dtrace]::
_Using and working on DTrace in FreeBSD_
+
DTrace is an integrated component of FreeBSD that provides a framework for understanding the kernel as well as user space programs at run time. The mailing list is an archived discussion for developers of the code as well as those using it.

link:{freebsd-eclipse-url}[freebsd-eclipse]::
_FreeBSD users of Eclipse IDE, tools, rich client applications and ports._
+
The intention of this list is to provide mutual support for everything to do with choosing, installing, using, developing and maintaining the Eclipse IDE, tools, rich client applications on the FreeBSD platform and assisting with the porting of Eclipse IDE and plugins to the FreeBSD environment.
+
The intention is also to facilitate exchange of information between the Eclipse community and the FreeBSD community to the mutual benefit of both.
+
Although this list is focused primarily on the needs of Eclipse users it will also provide a forum for those who would like to develop FreeBSD specific applications using the Eclipse framework.

link:{freebsd-embedded-url}[freebsd-embedded]::
_Using FreeBSD in embedded applications_
+
This list discusses topics related to using FreeBSD in embedded systems. This is a technical mailing list for which strictly technical content is expected. For the purpose of this list, embedded systems are those computing devices which are not desktops and which usually serve a single purpose as opposed to being general computing environments. Examples include, but are not limited to, all kinds of phone handsets, network equipment such as routers, switches and PBXs, remote measuring equipment, PDAs, Point Of Sale systems, and so on.

link:{freebsd-emulation-url}[freebsd-emulation]::
_Emulation of other systems such as Linux/MS-DOS(R)/Windows(R)_
+
This is a forum for technical discussions related to running programs written for other operating systems on FreeBSD.

link:{freebsd-enlightenment-url}[freebsd-enlightenment]::
_Enlightenment_
+
Discussions concerning the Enlightenment Desktop Environment for FreeBSD systems. This is a technical mailing list for which strictly technical content is expected.

link:{freebsd-eol-url}[freebsd-eol]::
_Peer support of FreeBSD-related software that is no longer supported by the FreeBSD Project._
+
This list is for those interested in providing or making use of peer support of FreeBSD-related software for which the FreeBSD Project no longer provides official support in the form of security advisories and patches.

link:{freebsd-firewire-url}[freebsd-firewire]::
_FireWire(R) (iLink, IEEE 1394)_
+
This is a mailing list for discussion of the design and implementation of a FireWire(R) (aka IEEE 1394 aka iLink) subsystem for FreeBSD. Relevant topics specifically include the standards, bus devices and their protocols, adapter boards/cards/chips sets, and the architecture and implementation of code for their proper support.

link:{freebsd-fortran-url}[freebsd-fortran]::
_Fortran on FreeBSD_
+
This is the mailing list for discussion of Fortran related ports on FreeBSD: compilers, libraries, scientific and engineering applications from laptops to HPC clusters.

link:{freebsd-fs-url}[freebsd-fs]::
_File systems_
+
Discussions concerning FreeBSD filesystems. This is a technical mailing list for which strictly technical content is expected.

link:{freebsd-games-url}[freebsd-games]::
_Games on FreeBSD_
+
This is a technical list for discussions related to bringing games to FreeBSD. It is for individuals actively working on porting games to FreeBSD, to bring up problems or discuss alternative solutions. Individuals interested in following the technical discussion are also welcome.

link:{freebsd-gecko-url}[freebsd-gecko]::
_Gecko Rendering Engine_
+
This is a forum about Gecko applications using FreeBSD.
+
Discussion centers around Gecko Ports applications, their installation, their development and their support within FreeBSD.

link:{freebsd-geom-url}[freebsd-geom]::
_GEOM_
+
Discussions specific to GEOM and related implementations. This is a technical mailing list for which strictly technical content is expected.

link:{freebsd-git-url}[freebsd-git]::
_Use of git in the FreeBSD project_
+
Discussions of how to use git in FreeBSD infrastructure including the github mirror and other uses of git for project collaboration. Discussion area for people using git against the FreeBSD github mirror. People wanting to get started with the mirror or git in general on FreeBSD can ask here.

link:{freebsd-gnome-url}[freebsd-gnome]::
_GNOME_
+
Discussions concerning The GNOME Desktop Environment for FreeBSD systems. This is a technical mailing list for which strictly technical content is expected.

link:{freebsd-infiniband-url}[freebsd-infiniband]::
_Infiniband on FreeBSD_
+
Technical mailing list discussing Infiniband, OFED, and OpenSM on FreeBSD.

link:{freebsd-ipfw-url}[freebsd-ipfw]::
_IP Firewall_
+
This is the forum for technical discussions concerning the redesign of the IP firewall code in FreeBSD. This is a technical mailing list for which strictly technical content is expected.

link:{freebsd-isdn-url}[freebsd-isdn]::
_ISDN Communications_
+
This is the mailing list for people discussing the development of ISDN support for FreeBSD.

link:{freebsd-java-url}[freebsd-java]::
_Java(TM) Development_
+
This is the mailing list for people discussing the development of significant Java(TM) applications for FreeBSD and the porting and maintenance of JDK(TM)s.

[[eresources-charters-jobs]]
link:{freebsd-jobs-url}[freebsd-jobs]::
_Jobs offered and sought_
+
This is a forum for posting employment notices specifically related to FreeBSD and resumes from those seeking FreeBSD-related employment. This is _not_ a mailing list for general employment issues since adequate forums for that already exist elsewhere.
+
Note that this list, like other `FreeBSD.org` mailing lists, is distributed worldwide. Be clear about the geographic location and the extent to which telecommuting or assistance with relocation is available.
+
Email should use open formats only - preferably plain text, but basic Portable Document Format (PDF), HTML, and a few others are acceptable to many readers. Closed formats such as Microsoft(R) Word ([.filename]#.doc#) will be rejected by the mailing list server.

link:{freebsd-kde-url}[freebsd-kde]::
_KDE_
+
Discussions concerning KDE on FreeBSD systems. This is a technical mailing list for which strictly technical content is expected.

link:{freebsd-hackers-url}[freebsd-hackers]::
_Technical discussions_
+
This is a forum for technical discussions related to FreeBSD. This is the primary technical mailing list. It is for individuals actively working on FreeBSD, to bring up problems or discuss alternative solutions. Individuals interested in following the technical discussion are also welcome. This is a technical mailing list for which strictly technical content is expected.

link:{freebsd-hardware-url}[freebsd-hardware]::
_General discussion of FreeBSD hardware_
+
General discussion about the types of hardware that FreeBSD runs on, various problems and suggestions concerning what to buy or avoid.

link:{freebsd-hubs-url}[freebsd-hubs]::
_Mirror sites_
+
Announcements and discussion for people who run FreeBSD mirror sites.

link:{freebsd-isp-url}[freebsd-isp]::
_Issues for Internet Service Providers_
+
This mailing list is for discussing topics relevant to Internet Service Providers (ISPs) using FreeBSD. This is a technical mailing list for which strictly technical content is expected.

link:{freebsd-mono-url}[freebsd-mono]::
_Mono and C# applications on FreeBSD_
+
This is a list for discussions related to the Mono development framework on FreeBSD. This is a technical mailing list. It is for individuals actively working on porting Mono or C# applications to FreeBSD, to bring up problems or discuss alternative solutions. Individuals interested in following the technical discussion are also welcome.

link:{freebsd-ocaml-url}[freebsd-ocaml]::
_FreeBSD-specific OCaml discussions_
+
This is a list for discussions related to the OCaml support on FreeBSD. This is a technical mailing list. It is for individuals working on OCaml ports, 3rd party libraries and frameworks. Individuals interested in the technical discussion are also welcome.

link:{freebsd-office-url}[freebsd-office]::
_Office applications on FreeBSD_
+
Discussion centers around office applications, their installation, their development and their support within FreeBSD.

link:{freebsd-ops-announce-url}[freebsd-ops-announce]::
_Project Infrastructure Announcements_
+
This is the mailing list for people interested in changes and issues related to the FreeBSD.org Project infrastructure.
+
This moderated list is strictly for announcements: no replies, requests, discussions, or opinions.

link:{freebsd-performance-url}[freebsd-performance]::
_Discussions about tuning or speeding up FreeBSD_
+
This mailing list exists to provide a place for hackers, administrators, and/or concerned parties to discuss performance related topics pertaining to FreeBSD. Acceptable topics includes talking about FreeBSD installations that are either under high load, are experiencing performance problems, or are pushing the limits of FreeBSD. Concerned parties that are willing to work toward improving the performance of FreeBSD are highly encouraged to subscribe to this list. This is a highly technical list ideally suited for experienced FreeBSD users, hackers, or administrators interested in keeping FreeBSD fast, robust, and scalable. This list is not a question-and-answer list that replaces reading through documentation, but it is a place to make contributions or inquire about unanswered performance related topics.

link:{freebsd-pf-url}[freebsd-pf]::
_Discussion and questions about the packet filter firewall system_
+
Discussion concerning the packet filter (pf) firewall system in terms of FreeBSD. Technical discussion and user questions are both welcome. This list is also a place to discuss the ALTQ QoS framework.

link:{freebsd-pkg-url}[freebsd-pkg]::
_Binary package management and package tools discussion_
+
Discussion of all aspects of managing FreeBSD systems by using binary packages to install software, including binary package toolkits and formats, their development and support within FreeBSD, package repository management, and third party packages.
+
Note that discussion of ports which fail to generate packages correctly should generally be considered as ports problems, and so inappropriate for this list.

link:{freebsd-pkg-fallout-url}[freebsd-pkg-fallout]::
_Fallout logs from package building_
+
All packages building failures logs from the package building clusters

link:{freebsd-pkgbase-url}[freebsd-pkgbase]::
_Packaging the FreeBSD base system._
+
Discussions surrounding implementation and issues regarding packaging the FreeBSD base system.

link:{freebsd-platforms-url}[freebsd-platforms]::
_Porting to Non Intel(R) platforms_
+
Cross-platform FreeBSD issues, general discussion and proposals for non Intel(R) FreeBSD ports. This is a technical mailing list for which strictly technical content is expected.

link:{freebsd-ports-url}[freebsd-ports]::
_Discussion of ""ports""_
+
Discussions concerning FreeBSD's ""ports collection"" ([.filename]#/usr/ports#), ports infrastructure, and general ports coordination efforts. This is a technical mailing list for which strictly technical content is expected.

link:{freebsd-ports-announce-url}[freebsd-ports-announce]::
_Important news and instructions about the FreeBSD ""Ports Collection""_
+
Important news for developers, porters, and users of the ""Ports Collection"" ([.filename]#/usr/ports#), including architecture/infrastructure changes, new capabilities, critical upgrade instructions, and release engineering information. This is a low-volume mailing list, intended for announcements.

link:{freebsd-ports-bugs-url}[freebsd-ports-bugs]::
_Discussion of ""ports"" bugs_
+
Discussions concerning problem reports for FreeBSD's ""ports collection"" ([.filename]#/usr/ports#), proposed ports, or modifications to ports. This is a technical mailing list for which strictly technical content is expected.

link:{freebsd-proliant-url}[freebsd-proliant]::
_Technical discussion of FreeBSD on HP ProLiant server platforms_
+
This mailing list is to be used for the technical discussion of the usage of FreeBSD on HP ProLiant servers, including the discussion of ProLiant-specific drivers, management software, configuration tools, and BIOS updates. As such, this is the primary place to discuss the hpasmd, hpasmcli, and hpacucli modules.

link:{freebsd-python-url}[freebsd-python]::
_Python on FreeBSD_
+
This is a list for discussions related to improving Python-support on FreeBSD. This is a technical mailing list. It is for individuals working on porting Python, its third party modules and Zope stuff to FreeBSD. Individuals interested in following the technical discussion are also welcome.

link:{freebsd-questions-url}[freebsd-questions]::
_User questions_
+
This is the mailing list for questions about FreeBSD. Do not send ""how to"" questions to the technical lists unless the question is quite technical.

link:{freebsd-ruby-url}[freebsd-ruby]::
_FreeBSD-specific Ruby discussions_
+
This is a list for discussions related to the Ruby support on FreeBSD. This is a technical mailing list. It is for individuals working on Ruby ports, third party libraries and frameworks.
+
Individuals interested in the technical discussion are also welcome.

link:{freebsd-scsi-url}[freebsd-scsi]::
_SCSI subsystem_
+
This is the mailing list for people working on the SCSI subsystem for FreeBSD. This is a technical mailing list for which strictly technical content is expected.

link:{freebsd-security-url}[freebsd-security]::
_Security issues_
+
FreeBSD computer security issues (DES, Kerberos, known security holes and fixes, etc). This is a technical mailing list for which strictly technical discussion is expected. Note that this is not a question-and-answer list, but that contributions (BOTH question AND answer) to the FAQ are welcome.

link:{freebsd-security-notifications-url}[freebsd-security-notifications]::
_Security Notifications_
+
Notifications of FreeBSD security problems and fixes. This is not a discussion list. The discussion list is FreeBSD-security.

link:{freebsd-snapshots-url}[freebsd-snapshots]::
_FreeBSD Development Snapshot Announcements_
+
This list provides notifications about the availability of new FreeBSD development snapshots for the head/ and stable/ branches.

link:{freebsd-stable-url}[freebsd-stable]::
_Discussions about the use of FreeBSD-STABLE_
+
This is the mailing list for users of FreeBSD-STABLE. ""STABLE"" is the branch where development continues after a RELEASE, including bug fixes and new features. The ABI is kept stable for binary compatibility. It includes warnings about new features coming out in -STABLE that will affect the users, and instructions on steps that must be taken to remain -STABLE. Anyone running ""STABLE"" should subscribe to this list. This is a technical mailing list for which strictly technical content is expected.

link:{freebsd-standards-url}[freebsd-standards]::
_C99 POSIX Conformance_
+
This is a forum for technical discussions related to FreeBSD Conformance to the C99 and the POSIX standards.

link:{freebsd-teaching-url}[freebsd-teaching]::
_Teaching with FreeBSD_
+
Non technical mailing list discussing teaching with FreeBSD.

link:{freebsd-testing-url}[freebsd-testing]::
_Testing on FreeBSD_
+
Technical mailing list discussing testing on FreeBSD, including ATF/Kyua, test build infrastructure, port tests to FreeBSD from other operating systems (NetBSD, ...), etc.

link:{freebsd-tex-url}[freebsd-tex]::
_Porting TeX and its applications to FreeBSD_
+
This is a technical mailing list for discussions related to TeX and its applications on FreeBSD. It is for individuals actively working on porting TeX to FreeBSD, to bring up problems or discuss alternative solutions. Individuals interested in following the technical discussion are also welcome.

link:{freebsd-toolchain-url}[freebsd-toolchain]::
_Maintenance of FreeBSD's integrated toolchain_
+
This is the mailing list for discussions related to the maintenance of the toolchain shipped with FreeBSD. This could include the state of Clang and GCC, but also pieces of software such as assemblers, linkers and debuggers.

link:{freebsd-transport-url}[freebsd-transport]::
_Discussions of transport level network protocols in FreeBSD_
+
The transport mailing list exists for the discussion of issues and designs around the transport level protocols in the FreeBSD network stack, including TCP, SCTP and UDP. Other networking topics, including driver specific and network protocol issues should be discussed on the {freebsd-net}.

link:{freebsd-translators-url}[freebsd-translators]::
_Translating FreeBSD documents and programs_
+
A discussion list where translators of FreeBSD documents from English into other languages can talk about translation methods and tools. New members are asked to introduce themselves and mention the languages they are interested in translating.

link:{freebsd-usb-url}[freebsd-usb]::
_Discussing FreeBSD support for USB_
+
This is a mailing list for technical discussions related to FreeBSD support for USB.

link:{freebsd-user-groups-url}[freebsd-user-groups]::
_User Group Coordination List_
+
This is the mailing list for the coordinators from each of the local area Users Groups to discuss matters with each other and a designated individual from the Core Team. This mail list should be limited to meeting synopsis and coordination of projects that span User Groups.

link:{freebsd-virtualization-url}[freebsd-virtualization]::
_Discussion of various virtualization techniques supported by FreeBSD_
+
A list to discuss the various virtualization techniques supported by FreeBSD. On one hand the focus will be on the implementation of the basic functionality as well as adding new features. On the other hand users will have a forum to ask for help in case of problems or to discuss their use cases.

link:{freebsd-wip-status-url}[freebsd-wip-status]::
_FreeBSD Work-In-Progress Status_
+
This mailing list can be used by developers to announce the creation and progress of FreeBSD related work. Messages will be moderated. It is suggested to send the message ""To:"" a more topical FreeBSD list and only ""BCC:"" this list. This way the WIP can also be discussed on the topical list, as no discussion is allowed on this list.
+
Look inside the archives for examples of suitable messages.
+
An editorial digest of the messages to this list might be posted to the FreeBSD website every few months as part of the Status Reports footnote:[https://www.freebsd.org/news/status/]. Past reports are archived.

link:{freebsd-wireless-url}[freebsd-wireless]::
_Discussions of 802.11 stack, tools device driver development_
+
The FreeBSD-wireless list focuses on 802.11 stack (sys/net80211), device driver and tools development. This includes bugs, new features and maintenance.

link:{freebsd-xen-url}[freebsd-xen]::
_Discussion of the FreeBSD port to Xen(TM) - implementation and usage_
+
A list that focuses on the FreeBSD Xen(TM) port. The anticipated traffic level is small enough that it is intended as a forum for both technical discussions of the implementation and design details as well as administrative deployment issues.

link:{freebsd-xfce-url}[freebsd-xfce]::
_XFCE_
+
This is a forum for discussions related to bring the XFCE environment to FreeBSD. This is a technical mailing list. It is for individuals actively working on porting XFCE to FreeBSD, to bring up problems or discuss alternative solutions. Individuals interested in following the technical discussion are also welcome.

link:{freebsd-zope-url}[freebsd-zope]::
_Zope_
+
This is a forum for discussions related to bring the Zope environment to FreeBSD. This is a technical mailing list. It is for individuals actively working on porting Zope to FreeBSD, to bring up problems or discuss alternative solutions. Individuals interested in following the technical discussion are also welcome.

[[eresources-mailfiltering]]
[.title]
=== Filtering on the Mailing Lists

The FreeBSD mailing lists are filtered in multiple ways to avoid the distribution of spam, viruses, and other unwanted emails. The filtering actions described in this section do not include all those used to protect the mailing lists.

Only certain types of attachments are allowed on the mailing lists. All attachments with a MIME content type not found in the list below will be stripped before an email is distributed on the mailing lists.

* application/octet-stream
* application/pdf
* application/pgp-signature
* application/x-pkcs7-signature
* message/rfc822
* multipart/alternative
* multipart/related
* multipart/signed
* text/html
* text/plain
* text/x-diff
* text/x-patch

[.note]
====
[.admontitle]*Note:* +

Some of the mailing lists might allow attachments of other MIME content types, but the above list should be applicable for most of the mailing lists.
====

If an email contains both an HTML and a plain text version, the HTML version will be removed. If an email contains only an HTML version, it will be converted to plain text.

[[eresources-news]]
[.title]
== Usenet Newsgroups

In addition to two FreeBSD specific newsgroups, there are many others in which FreeBSD is discussed or are otherwise relevant to FreeBSD users.

[.title]
=== BSD Specific Newsgroups

* link:news:comp.unix.bsd.freebsd.announce[comp.unix.bsd.freebsd.announce]
* link:news:comp.unix.bsd.freebsd.misc[comp.unix.bsd.freebsd.misc]
* link:news:de.comp.os.unix.bsd[de.comp.os.unix.bsd] (German)
* link:news:fr.comp.os.bsd[fr.comp.os.bsd] (French)

[.title]
=== Other UNIX(R) Newsgroups of Interest

* link:news:comp.unix[comp.unix]
* link:news:comp.unix.questions[comp.unix.questions]
* link:news:comp.unix.admin[comp.unix.admin]
* link:news:comp.unix.programmer[comp.unix.programmer]
* link:news:comp.unix.shell[comp.unix.shell]
* link:news:comp.unix.misc[comp.unix.misc]
* link:news:comp.unix.bsd[comp.unix.bsd]

[.title]
=== X Window System

* link:news:comp.windows.x[comp.windows.x]

[[eresources-web]]
[.title]
== Official Mirrors

<<central-mirrors, {central}>>, <<armenia-mirrors, {mirrors-armenia}>>, <<australia-mirrors, {mirrors-australia}>>, <<austria-mirrors, {mirrors-austria}>>, <<czech-republic-mirrors, {mirrors-czech}>>, <<denmark-mirrors, {mirrors-denmark}>>, <<finland-mirrors, {mirrors-finland}>>, <<france-mirrors, {mirrors-france}>>, <<germany-mirrors, {mirrors-germany}>>, <<hong-kong-mirrors, {mirrors-hongkong}>>, <<ireland-mirrors, {mirrors-ireland}>>, <<japan-mirrors, {mirrors-japan}>>, <<latvia-mirrors, {mirrors-latvia}>>, <<lithuania-mirrors, {mirrors-lithuania}>>, <<netherlands-mirrors, {mirrors-netherlands}>>, <<norway-mirrors, {mirrors-norway}>>, <<russia-mirrors, {mirrors-russia}>>, <<slovenia-mirrors, {mirrors-slovenia}>>, <<south-africa-mirrors, {mirrors-south-africa}>>, <<spain-mirrors, {mirrors-spain}>>, <<sweden-mirrors, {mirrors-sweden}>>, <<switzerland-mirrors, {mirrors-switzerland}>>, <<taiwan-mirrors, {mirrors-taiwan}>>, <<uk-mirrors, {mirrors-uk}>>, <<usa-mirrors, {mirrors-us}>>.

(as of UTC)

[[central-mirrors]]
*{central}*

* {central-www}

[[armenia-mirrors]]
*{mirrors-armenia}*

* {mirrors-armenia-www-httpv6} (IPv6)

[[australia-mirrors]]
*{mirrors-australia}*

* {mirrors-australia-www-http}
* {mirrors-australia-www2-http}

[[austria-mirrors]]
*{mirrors-austria}*

* {mirrors-armenia-www-httpv6} (IPv6)

[[czech-republic-mirrors]]
*{mirrors-czech}*

* {mirrors-czech-www-httpv6} (IPv6)

[[denmark-mirrors]]
*{mirrors-denmark}*

* {mirrors-denmark-www-httpv6} (IPv6)

[[finland-mirrors]]
*{mirrors-finland}*

* {mirrors-finland-www-http}

[[france-mirrors]]
*{mirrors-france}*

* {mirrors-france-www-http}

[[germany-mirrors]]
*{mirrors-germany}*

* {mirrors-germany-www-http}

[[hong-kong-mirrors]]
*{mirrors-hongkong}*

* {mirrors-hongkong-www}

[[ireland-mirrors]]
*{mirrors-ireland}*

* {mirrors-ireland-www} 

[[japan-mirrors]]
*{mirrors-japan}*

* {mirrors-japan-www-httpv6} (IPv6)

[[latvia-mirrors]]
*{mirrors-latvia}*

* {mirrors-latvia-www} 

[[lithuania-mirrors]]
*{mirrors-lithuania}*

* {mirrors-lithuania-www} 

[[netherlands-mirrors]]
*{mirrors-netherlands}*

* {mirrors-netherlands-www} 

[[norway-mirrors]]
*{mirrors-norway}*

* {mirrors-norway-www} 

[[russia-mirrors]]
*{mirrors-russia}*

* {mirrors-russia-www-httpv6} (IPv6)

[[slovenia-mirrors]]
*{mirrors-slovenia}*

* {mirrors-slovenia-www} 

[[south-africa-mirrors]]
*{mirrors-south-africa}*

* {mirrors-south-africa-www}

[[spain-mirrors]]
*{mirrors-spain}*

* {mirrors-spain-www}
* {mirrors-spain-www2}

[[sweden-mirrors]]
*{mirrors-sweden}*

* {mirrors-sweden-www}

[[switzerland-mirrors]]
*{mirrors-switzerland}*

* {mirrors-switzerland-www-httpv6} (IPv6)
* {mirrors-switzerland-www2-httpv6} (IPv6)

[[taiwan-mirrors]]
*{mirrors-taiwan}*

* {mirrors-taiwan-www}
* {mirrors-taiwan-www2}
* {mirrors-taiwan-www4}
* {mirrors-taiwan-www5-httpv6} (IPv6)

[[uk-mirrors]]
*{mirrors-uk}*

* {mirrors-uk-www}
* {mirrors-uk-www3}

[[usa-mirrors]]
*{mirrors-us}*

* {mirrors-us-www5-httpv6} (IPv6)

:sectnums:
",12302,False,2439.5694278530777,median
"//========================================================================
//
// HtmlOutputDev.cc
//
// Copyright 1997-2002 Glyph & Cog, LLC
//
// Changed 1999-2000 by G.Ovtcharov
//
// Changed 2002 by Mikhail Kruk
//
//========================================================================

//========================================================================
//
// Modified under the Poppler project - http://poppler.freedesktop.org
//
// All changes made under the Poppler project to this file are licensed
// under GPL version 2 or later
//
// Copyright (C) 2005-2013 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2008 Kjartan Maraas <kmaraas@gnome.org>
// Copyright (C) 2008 Boris Toloknov <tlknv@yandex.ru>
// Copyright (C) 2008 Haruyuki Kawabe <Haruyuki.Kawabe@unisys.co.jp>
// Copyright (C) 2008 Tomas Are Haavet <tomasare@gmail.com>
// Copyright (C) 2009 Warren Toomey <wkt@tuhs.org>
// Copyright (C) 2009, 2011 Carlos Garcia Campos <carlosgc@gnome.org>
// Copyright (C) 2009 Reece Dunn <msclrhd@gmail.com>
// Copyright (C) 2010, 2012 Adrian Johnson <ajohnson@redneon.com>
// Copyright (C) 2010 Hib Eris <hib@hiberis.nl>
// Copyright (C) 2010 OSSD CDAC Mumbai by Leena Chourey (leenac@cdacmumbai.in) and Onkar Potdar (onkar@cdacmumbai.in)
// Copyright (C) 2011 Joshua Richardson <jric@chegg.com>
// Copyright (C) 2011 Stephen Reichling <sreichling@chegg.com>
// Copyright (C) 2011, 2012 Igor Slepchin <igor.slepchin@gmail.com>
// Copyright (C) 2012 Ihar Filipau <thephilips@gmail.com>
// Copyright (C) 2012 Gerald Schmidt <solahcin@gmail.com>
// Copyright (C) 2012 Pino Toscano <pino@kde.org>
// Copyright (C) 2013 Thomas Freitag <Thomas.Freitag@alfa.de>
// Copyright (C) 2013 Julien Nabet <serval2412@yahoo.fr>
// Copyright (C) 2013 Johannes Brandstätter <jbrandstaetter@gmail.com>
//
// To see a description of the changes please see the Changelog file that
// came with your tarball or type make ChangeLog if you are building from git
//
//========================================================================

#ifdef __GNUC__
#pragma implementation
#endif

#include ""config.h""
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stddef.h>
#include <ctype.h>
#include <math.h>
#include <iostream>
#include ""goo/GooString.h""
#include ""goo/GooList.h""
#include ""UnicodeMap.h""
#include ""goo/gmem.h""
#include ""Error.h""
#include ""GfxState.h""
#include ""Page.h""
#include ""Annot.h""
#include ""PNGWriter.h""
#include ""GlobalParams.h""
#include ""HtmlOutputDev.h""
#include ""HtmlFonts.h""
#include ""HtmlUtils.h""
#include ""Outline.h""
#include ""PDFDoc.h""

#ifdef ENABLE_LIBPNG
#include <png.h>
#endif

#define DEBUG __FILE__ << "": "" << __LINE__ << "": DEBUG: ""

class HtmlImage
{
public:
    HtmlImage(GooString *_fName, GfxState *state)
      : fName(_fName) {
    state->transform(0, 0, &xMin, &yMax);
    state->transform(1, 1, &xMax, &yMin);
  }
 ~HtmlImage() { delete fName; }

  double xMin, xMax;		// image x coordinates
  double yMin, yMax;		// image y coordinates
  GooString  *fName;		// image file name
};

// returns true if x is closer to y than x is to z
static inline bool IS_CLOSER(float x, float y, float z) { return fabs((x)-(y)) < fabs((x)-(z)); }

extern GBool complexMode;
extern GBool singleHtml;
extern GBool ignore;
extern GBool printCommands;
extern GBool printHtml;
extern GBool noframes;
extern GBool stout;
extern GBool xml;
extern GBool showHidden;
extern GBool noMerge;

extern double wordBreakThreshold;

static GBool debug = gFalse;
static GooString *gstr_buff0 = NULL; // a workspace in which I format strings

static GooString* basename(GooString* str){
  
  char *p=str->getCString();
  int len=str->getLength();
  for (int i=len-1;i>=0;i--)
    if (*(p+i)==SLASH) 
      return new GooString((p+i+1),len-i-1);
  return new GooString(str);
}

#if 0
static GooString* Dirname(GooString* str){
  
  char *p=str->getCString();
  int len=str->getLength();
  for (int i=len-1;i>=0;i--)
    if (*(p+i)==SLASH) 
      return new GooString(p,i+1);
  return new GooString();
} 
#endif

static const char *print_matrix(const double *mat) {
  delete gstr_buff0;

  gstr_buff0 =  GooString::format(""[{0:g} {1:g} {2:g} {3:g} {4:g} {5:g}]"",
                                  *mat, mat[1], mat[2], mat[3], mat[4], mat[5]);
  return gstr_buff0->getCString();
}

static const char *print_uni_str(const Unicode *u, const unsigned uLen) {
  GooString *gstr_buff1 = NULL;

  delete gstr_buff0;

  if (!uLen) return """";
  gstr_buff0 = GooString::format(""{0:c}"", (*u < 0x7F ? *u & 0xFF : '?'));
  for (unsigned i = 1; i < uLen; i++) {
    if (u[i] < 0x7F) {
      gstr_buff1 = gstr_buff0->append(u[i] < 0x7F ? static_cast<char>(u[i]) & 0xFF : '?');
      delete gstr_buff0;
      gstr_buff0 = gstr_buff1;
    }
  }

  return gstr_buff0->getCString();
}

//------------------------------------------------------------------------
// HtmlString
//------------------------------------------------------------------------

HtmlString::HtmlString(GfxState *state, double fontSize, HtmlFontAccu* _fonts) : fonts(_fonts) {
  GfxFont *font;
  double x, y;

  state->transform(state->getCurX(), state->getCurY(), &x, &y);
  if ((font = state->getFont())) {
    double ascent = font->getAscent();
    double descent = font->getDescent();
    if( ascent > 1.05 ){
        //printf( ""ascent=%.15g is too high, descent=%.15g\\n"", ascent, descent );
        ascent = 1.05;
    }
    if( descent < -0.4 ){
        //printf( ""descent %.15g is too low, ascent=%.15g\\n"", descent, ascent );
        descent = -0.4;
    }
    yMin = y - ascent * fontSize;
    yMax = y - descent * fontSize;
    GfxRGB rgb;
    state->getFillRGB(&rgb);
    HtmlFont hfont=HtmlFont(font, static_cast<int>(fontSize-1), rgb);
    if (isMatRotOrSkew(state->getTextMat())) {
      double normalizedMatrix[4];
      memcpy(normalizedMatrix, state->getTextMat(), sizeof(normalizedMatrix));
      // browser rotates the opposite way
      // so flip the sign of the angle -> sin() components change sign
      if (debug)
        std::cerr << DEBUG << ""before transform: "" << print_matrix(normalizedMatrix) << std::endl;
      normalizedMatrix[1] *= -1;
      normalizedMatrix[2] *= -1;
      if (debug)
        std::cerr << DEBUG << ""after reflecting angle: "" << print_matrix(normalizedMatrix) << std::endl;
      normalizeRotMat(normalizedMatrix);
      if (debug)
        std::cerr << DEBUG << ""after norm: "" << print_matrix(normalizedMatrix) << std::endl;
      hfont.setRotMat(normalizedMatrix);
    }
    fontpos = fonts->AddFont(hfont);
  } else {
    // this means that the PDF file draws text without a current font,
    // which should never happen
    yMin = y - 0.95 * fontSize;
    yMax = y + 0.35 * fontSize;
    fontpos=0;
  }
  if (yMin == yMax) {
    // this is a sanity check for a case that shouldn't happen -- but
    // if it does happen, we want to avoid dividing by zero later
    yMin = y;
    yMax = y + 1;
  }
  col = 0;
  text = NULL;
  xRight = NULL;
  link = NULL;
  len = size = 0;
  yxNext = NULL;
  xyNext = NULL;
  htext=new GooString();
  dir = textDirUnknown;
}


HtmlString::~HtmlString() {
  gfree(text);
  delete htext;
  gfree(xRight);
}

void HtmlString::addChar(GfxState *state, double x, double y,
			 double dx, double dy, Unicode u) {
  if (dir == textDirUnknown) {
    //dir = UnicodeMap::getDirection(u);
    dir = textDirLeftRight;
  } 

  if (len == size) {
    size += 16;
    text = (Unicode *)grealloc(text, size * sizeof(Unicode));
    xRight = (double *)grealloc(xRight, size * sizeof(double));
  }
  text[len] = u;
  if (len == 0) {
    xMin = x;
  }
  xMax = xRight[len] = x + dx;
//printf(""added char: %f %f xright = %f\\n"", x, dx, x+dx);
  ++len;
}

void HtmlString::endString()
{
  if( dir == textDirRightLeft && len > 1 )
  {
    //printf(""will reverse!\\n"");
    for (int i = 0; i < len / 2; i++)
    {
      Unicode ch = text[i];
      text[i] = text[len - i - 1];
      text[len - i - 1] = ch;
    }
  }
}

//------------------------------------------------------------------------
// HtmlPage
//------------------------------------------------------------------------

HtmlPage::HtmlPage(GBool rawOrder, char *imgExtVal) {
  this->rawOrder = rawOrder;
  curStr = NULL;
  yxStrings = NULL;
  xyStrings = NULL;
  yxCur1 = yxCur2 = NULL;
  fonts=new HtmlFontAccu();
  links=new HtmlLinks();
  imgList=new GooList();
  pageWidth=0;
  pageHeight=0;
  fontsPageMarker = 0;
  DocName=NULL;
  firstPage = -1;
  imgExt = new GooString(imgExtVal);
}

HtmlPage::~HtmlPage() {
  clear();
  delete DocName;
  delete fonts;
  delete links;
  delete imgExt;
  deleteGooList(imgList, HtmlImage);
}

void HtmlPage::updateFont(GfxState *state) {
  GfxFont *font;
  double *fm;
  char *name;
  int code;
  double w;
  
  // adjust the font size
  fontSize = state->getTransformedFontSize();
  if ((font = state->getFont()) && font->getType() == fontType3) {
    // This is a hack which makes it possible to deal with some Type 3
    // fonts.  The problem is that it's impossible to know what the
    // base coordinate system used in the font is without actually
    // rendering the font.  This code tries to guess by looking at the
    // width of the character 'm' (which breaks if the font is a
    // subset that doesn't contain 'm').
    for (code = 0; code < 256; ++code) {
      if ((name = ((Gfx8BitFont *)font)->getCharName(code)) &&
	  name[0] == 'm' && name[1] == '\\0') {
	break;
      }
    }
    if (code < 256) {
      w = ((Gfx8BitFont *)font)->getWidth(code);
      if (w != 0) {
	// 600 is a generic average 'm' width -- yes, this is a hack
	fontSize *= w / 0.6;
      }
    }
    fm = font->getFontMatrix();
    if (fm[0] != 0) {
      fontSize *= fabs(fm[3] / fm[0]);
    }
  }
}

void HtmlPage::beginString(GfxState *state, GooString *s) {
  curStr = new HtmlString(state, fontSize, fonts);
}


void HtmlPage::conv(){
  HtmlString *tmp;

  int linkIndex = 0;
  HtmlFont* h;
  for(tmp=yxStrings;tmp;tmp=tmp->yxNext){
     int pos=tmp->fontpos;
     //  printf(""%d\\n"",pos);
     h=fonts->Get(pos);

     if (tmp->htext) delete tmp->htext; 
     tmp->htext=HtmlFont::simple(h,tmp->text,tmp->len);

     if (links->inLink(tmp->xMin,tmp->yMin,tmp->xMax,tmp->yMax, linkIndex)){
       tmp->link = links->getLink(linkIndex);
       /*GooString *t=tmp->htext;
       tmp->htext=links->getLink(k)->Link(tmp->htext);
       delete t;*/
     }
  }

}


void HtmlPage::addChar(GfxState *state, double x, double y,
		       double dx, double dy, 
			double ox, double oy, Unicode *u, int uLen) {
  double x1, y1, w1, h1, dx2, dy2;
  int n, i;
  state->transform(x, y, &x1, &y1);
  n = curStr->len;
 
  // check that new character is in the same direction as current string
  // and is not too far away from it before adding 
  //if ((UnicodeMap::getDirection(u[0]) != curStr->dir) || 
  // XXX
  if (debug) {
    double *text_mat = state->getTextMat();
    // rotation is (cos q, sin q, -sin q, cos q, 0, 0)
    // sin q is zero iff there is no rotation, or 180 deg. rotation;
    // for 180 rotation, cos q will be negative
    if (text_mat[0] < 0 || !is_within(text_mat[1], .1, 0)) {
      std::cerr << DEBUG << ""rotation matrix for \\"""" << print_uni_str(u, uLen) << '""' << std::endl;
      std::cerr << ""text "" << print_matrix(state->getTextMat());
    }
  }
  if (n > 0 && // don't start a new string, unless there is already a string
      // TODO: the following line assumes that text is flowing left to
      // right, which will not necessarily be the case, e.g. if rotated;
      // It assesses whether or not two characters are close enough to
      // be part of the same string
      fabs(x1 - curStr->xRight[n-1]) > wordBreakThreshold * (curStr->yMax - curStr->yMin) &&
      // rotation is (cos q, sin q, -sin q, cos q, 0, 0)
      // sin q is zero iff there is no rotation, or 180 deg. rotation;
      // for 180 rotation, cos q will be negative
      !rot_matrices_equal(curStr->getFont().getRotMat(), state->getTextMat()))
  {
    endString();
    beginString(state, NULL);
  }
  state->textTransformDelta(state->getCharSpace() * state->getHorizScaling(),
			    0, &dx2, &dy2);
  dx -= dx2;
  dy -= dy2;
  state->transformDelta(dx, dy, &w1, &h1);
  if (uLen != 0) {
    w1 /= uLen;
    h1 /= uLen;
  }
  for (i = 0; i < uLen; ++i) {
    curStr->addChar(state, x1 + i*w1, y1 + i*h1, w1, h1, u[i]);
  }
}

void HtmlPage::endString() {
  HtmlString *p1, *p2;
  double h, y1, y2;

  // throw away zero-length strings -- they don't have valid xMin/xMax
  // values, and they're useless anyway
  if (curStr->len == 0) {
    delete curStr;
    curStr = NULL;
    return;
  }

  curStr->endString();

#if 0 //~tmp
  if (curStr->yMax - curStr->yMin > 20) {
    delete curStr;
    curStr = NULL;
    return;
  }
#endif

  // insert string in y-major list
  h = curStr->yMax - curStr->yMin;
  y1 = curStr->yMin + 0.5 * h;
  y2 = curStr->yMin + 0.8 * h;
  if (rawOrder) {
    p1 = yxCur1;
    p2 = NULL;
  } else if ((!yxCur1 ||
              (y1 >= yxCur1->yMin &&
               (y2 >= yxCur1->yMax || curStr->xMax >= yxCur1->xMin))) &&
             (!yxCur2 ||
              (y1 < yxCur2->yMin ||
               (y2 < yxCur2->yMax && curStr->xMax < yxCur2->xMin)))) {
    p1 = yxCur1;
    p2 = yxCur2;
  } else {
    for (p1 = NULL, p2 = yxStrings; p2; p1 = p2, p2 = p2->yxNext) {
      if (y1 < p2->yMin || (y2 < p2->yMax && curStr->xMax < p2->xMin))
        break;
    }
    yxCur2 = p2;
  }
  yxCur1 = curStr;
  if (p1)
    p1->yxNext = curStr;
  else
    yxStrings = curStr;
  curStr->yxNext = p2;
  curStr = NULL;
}

static const char *strrstr( const char *s, const char *ss )
{
  const char *p = strstr( s, ss );
  for( const char *pp = p; pp != NULL; pp = strstr( p+1, ss ) ){
    p = pp;
  }
  return p;
}

static void CloseTags( GooString *htext, GBool &finish_a, GBool &finish_italic, GBool &finish_bold )
{
  const char *last_italic = finish_italic && ( finish_bold   || finish_a    ) ? strrstr( htext->getCString(), ""<i>"" ) : NULL;
  const char *last_bold   = finish_bold   && ( finish_italic || finish_a    ) ? strrstr( htext->getCString(), ""<b>"" ) : NULL;
  const char *last_a      = finish_a      && ( finish_italic || finish_bold ) ? strrstr( htext->getCString(), ""<a "" ) : NULL;
  if( finish_a && ( finish_italic || finish_bold ) && last_a > ( last_italic > last_bold ? last_italic : last_bold ) ){
    htext->append(""</a>"", 4);
    finish_a = false;
  }
  if( finish_italic && finish_bold && last_italic > last_bold ){
    htext->append(""</i>"", 4);
    finish_italic = false;
  }
  if( finish_bold )
    htext->append(""</b>"", 4);
  if( finish_italic )
    htext->append(""</i>"", 4);
  if( finish_a )
    htext->append(""</a>"");
}

// Strings are lines of text;
// This function aims to combine strings into lines and paragraphs if !noMerge
// It may also strip out duplicate strings (if they are on top of each other); sometimes they are to create a font effect
void HtmlPage::coalesce() {
  HtmlString *str1, *str2;
  HtmlFont *hfont1, *hfont2;
  double space, horSpace, vertSpace, vertOverlap;
  GBool addSpace, addLineBreak;
  int n, i;
  double curX, curY;

#if 0 //~ for debugging
  for (str1 = yxStrings; str1; str1 = str1->yxNext) {
    printf(""x=%f..%f  y=%f..%f  size=%2d '"",
	   str1->xMin, str1->xMax, str1->yMin, str1->yMax,
	   (int)(str1->yMax - str1->yMin));
    for (i = 0; i < str1->len; ++i) {
      fputc(str1->text[i] & 0xff, stdout);
    }
    printf(""'\\n"");
  }
  printf(""\\n------------------------------------------------------------\\n\\n"");
#endif
  str1 = yxStrings;

  if( !str1 ) return;

  //----- discard duplicated text (fake boldface, drop shadows)
  if( !complexMode )
  {	/* if not in complex mode get rid of duplicate strings */
	HtmlString *str3;
	GBool found;
  	while (str1)
	{
		double size = str1->yMax - str1->yMin;
		double xLimit = str1->xMin + size * 0.2;
		found = gFalse;
		for (str2 = str1, str3 = str1->yxNext;
			str3 && str3->xMin < xLimit;
			str2 = str3, str3 = str2->yxNext)
		{
			if (str3->len == str1->len &&
				!memcmp(str3->text, str1->text, str1->len * sizeof(Unicode)) &&
				fabs(str3->yMin - str1->yMin) < size * 0.2 &&
				fabs(str3->yMax - str1->yMax) < size * 0.2 &&
				fabs(str3->xMax - str1->xMax) < size * 0.2)
			{
				found = gTrue;
				//printf(""found duplicate!\\n"");
				break;
			}
		}
		if (found)
		{
			str2->xyNext = str3->xyNext;
			str2->yxNext = str3->yxNext;
			delete str3;
		}
		else
		{
			str1 = str1->yxNext;
		}
	}		
  }	/*- !complexMode */
  
  str1 = yxStrings;
  
  hfont1 = getFont(str1);
  if( hfont1->isBold() )
    str1->htext->insert(0,""<b>"",3);
  if( hfont1->isItalic() )
    str1->htext->insert(0,""<i>"",3);
  if( str1->getLink() != NULL ) {
    GooString *ls = str1->getLink()->getLinkStart();
    str1->htext->insert(0, ls);
    delete ls;
  }
  curX = str1->xMin; curY = str1->yMin;

  while (str1 && (str2 = str1->yxNext)) {
    hfont2 = getFont(str2);
    space = str1->yMax - str1->yMin; // the height of the font's bounding box
    horSpace = str2->xMin - str1->xMax;
    // if strings line up on left-hand side AND they are on subsequent lines, we need a line break
    addLineBreak = !noMerge && (fabs(str1->xMin - str2->xMin) < 0.4) && IS_CLOSER(str2->yMax, str1->yMax + space, str1->yMax);
    vertSpace = str2->yMin - str1->yMax;

//printf(""coalesce %d %d %f? "", str1->dir, str2->dir, d);

    if (str2->yMin >= str1->yMin && str2->yMin <= str1->yMax)
    {
	vertOverlap = str1->yMax - str2->yMin;
    } else
    if (str2->yMax >= str1->yMin && str2->yMax <= str1->yMax)
    {
	vertOverlap = str2->yMax - str1->yMin;
    } else
    {
    	vertOverlap = 0;
    } 
    
    // Combine strings if:
    //  They appear to be the same font (complex mode only) && going in the same direction AND at least one of the following:
    //  1.  They appear to be part of the same line of text
    //  2.  They appear to be subsequent lines of a paragraph
    //  We assume (1) or (2) above, respectively, based on:
    //  (1)  strings overlap vertically AND
    //       horizontal space between end of str1 and start of str2 is consistent with a single space or less;
    //       when rawOrder, the strings have to overlap vertically by at least 50%
    //  (2)  Strings flow down the page, but the space between them is not too great, and they are lined up on the left
    if (
	(
	 (
	  (
	   (rawOrder && vertOverlap > 0.5 * space) 
	   ||
	   (!rawOrder && str2->yMin < str1->yMax)
	  ) &&
	  (horSpace > -0.5 * space && horSpace < space)
	 ) ||
       	 (vertSpace >= 0 && vertSpace < 0.5 * space && addLineBreak)
	) &&
	(!complexMode || (hfont1->isEqualIgnoreBold(*hfont2))) && // in complex mode fonts must be the same, in other modes fonts do not metter
	str1->dir == str2->dir // text direction the same
       ) 
    {
//      printf(""yes\\n"");
      n = str1->len + str2->len;
      if ((addSpace = horSpace > wordBreakThreshold * space)) {
        ++n;
      }
      if (addLineBreak) {
        ++n;
      }
  
      str1->size = (n + 15) & ~15;
      str1->text = (Unicode *)grealloc(str1->text,
				       str1->size * sizeof(Unicode));
      str1->xRight = (double *)grealloc(str1->xRight,
					str1->size * sizeof(double));
      if (addSpace) {
		  str1->text[str1->len] = 0x20;
		  str1->htext->append(xml?"" "":""&#160;"");
		  str1->xRight[str1->len] = str2->xMin;
		  ++str1->len;
      }
      if (addLineBreak) {
	  str1->text[str1->len] = '\\n';
	  str1->htext->append(""<br/>"");
	  str1->xRight[str1->len] = str2->xMin;
	  ++str1->len;
	  str1->yMin = str2->yMin;
	  str1->yMax = str2->yMax;
	  str1->xMax = str2->xMax;
	  int fontLineSize = hfont1->getLineSize();
	  int curLineSize = (int)(vertSpace + space); 
	  if( curLineSize != fontLineSize )
	  {
	      HtmlFont *newfnt = new HtmlFont(*hfont1);
	      newfnt->setLineSize(curLineSize);
	      str1->fontpos = fonts->AddFont(*newfnt);
	      delete newfnt;
	      hfont1 = getFont(str1);
	      // we have to reget hfont2 because it's location could have
	      // changed on resize
	      hfont2 = getFont(str2); 
	  }
      }
      for (i = 0; i < str2->len; ++i) {
	str1->text[str1->len] = str2->text[i];
	str1->xRight[str1->len] = str2->xRight[i];
	++str1->len;
      }

      /* fix <i>, <b> if str1 and str2 differ and handle switch of links */
      HtmlLink *hlink1 = str1->getLink();
      HtmlLink *hlink2 = str2->getLink();
      bool switch_links = !hlink1 || !hlink2 || !hlink1->isEqualDest(*hlink2);
      GBool finish_a = switch_links && hlink1 != NULL;
      GBool finish_italic = hfont1->isItalic() && ( !hfont2->isItalic() || finish_a );
      GBool finish_bold   = hfont1->isBold()   && ( !hfont2->isBold()   || finish_a || finish_italic );
      CloseTags( str1->htext, finish_a, finish_italic, finish_bold );
      if( switch_links && hlink2 != NULL ) {
        GooString *ls = hlink2->getLinkStart();
        str1->htext->append(ls);
        delete ls;
      }
      if( ( !hfont1->isItalic() || finish_italic ) && hfont2->isItalic() )
	    str1->htext->append(""<i>"", 3);
      if( ( !hfont1->isBold() || finish_bold ) && hfont2->isBold() )
	    str1->htext->append(""<b>"", 3);


      str1->htext->append(str2->htext);
      // str1 now contains href for link of str2 (if it is defined)
      str1->link = str2->link; 
      hfont1 = hfont2;
      if (str2->xMax > str1->xMax) {
	str1->xMax = str2->xMax;
      }
      if (str2->yMax > str1->yMax) {
	str1->yMax = str2->yMax;
      }
      str1->yxNext = str2->yxNext;
      delete str2;
    } else { // keep strings separate
//      printf(""no\\n""); 
      GBool finish_a = str1->getLink() != NULL;
      GBool finish_bold   = hfont1->isBold();
      GBool finish_italic = hfont1->isItalic();
      CloseTags( str1->htext, finish_a, finish_italic, finish_bold );
     
      str1->xMin = curX; str1->yMin = curY; 
      str1 = str2;
      curX = str1->xMin; curY = str1->yMin;
      hfont1 = hfont2;
      if( hfont1->isBold() )
	str1->htext->insert(0,""<b>"",3);
      if( hfont1->isItalic() )
	str1->htext->insert(0,""<i>"",3);
      if( str1->getLink() != NULL ) {
	GooString *ls = str1->getLink()->getLinkStart();
	str1->htext->insert(0, ls);
	delete ls;
      }
    }
  }
  str1->xMin = curX; str1->yMin = curY;

  GBool finish_bold   = hfont1->isBold();
  GBool finish_italic = hfont1->isItalic();
  GBool finish_a = str1->getLink() != NULL;
  CloseTags( str1->htext, finish_a, finish_italic, finish_bold );

#if 0 //~ for debugging
  for (str1 = yxStrings; str1; str1 = str1->yxNext) {
    printf(""x=%3d..%3d  y=%3d..%3d  size=%2d "",
	   (int)str1->xMin, (int)str1->xMax, (int)str1->yMin, (int)str1->yMax,
	   (int)(str1->yMax - str1->yMin));
    printf(""'%s'\\n"", str1->htext->getCString());  
  }
  printf(""\\n------------------------------------------------------------\\n\\n"");
#endif

}

void HtmlPage::dumpAsXML(FILE* f,int page){  
  fprintf(f, ""<page number=\\""%d\\"" position=\\""absolute\\"""", page);
  fprintf(f,"" top=\\""0\\"" left=\\""0\\"" height=\\""%d\\"" width=\\""%d\\"">\\n"", pageHeight,pageWidth);
    
  for(int i=fontsPageMarker;i < fonts->size();i++) {
    GooString *fontCSStyle = fonts->CSStyle(i);
    fprintf(f,""\\t%s\\n"",fontCSStyle->getCString());
    delete fontCSStyle;
  }
  
  int listlen=imgList->getLength();
  for (int i = 0; i < listlen; i++) {
    HtmlImage *img = (HtmlImage*)imgList->del(0);
    fprintf(f,""<image top=\\""%d\\"" left=\\""%d\\"" "",xoutRound(img->yMin),xoutRound(img->xMin));
    fprintf(f,""width=\\""%d\\"" height=\\""%d\\"" "",xoutRound(img->xMax-img->xMin),xoutRound(img->yMax-img->yMin));
    fprintf(f,""src=\\""%s\\""/>\\n"",img->fName->getCString());
    delete img;
  }

  for(HtmlString *tmp=yxStrings;tmp;tmp=tmp->yxNext){
    if (tmp->htext){
      fprintf(f,""<text top=\\""%d\\"" left=\\""%d\\"" "",xoutRound(tmp->yMin),xoutRound(tmp->xMin));
      fprintf(f,""width=\\""%d\\"" height=\\""%d\\"" "",xoutRound(tmp->xMax-tmp->xMin),xoutRound(tmp->yMax-tmp->yMin));
      fprintf(f,""font=\\""%d\\"">"", tmp->fontpos);
      fputs(tmp->htext->getCString(),f);
      fputs(""</text>\\n"",f);
    }
  }
  fputs(""</page>\\n"",f);
}

static void printCSS(FILE *f)
{
  // Image flip/flop CSS
  // Source:
  // http://stackoverflow.com/questions/1309055/cross-browser-way-to-flip-html-image-via-javascript-css
  // tested in Chrome, Fx (Linux) and IE9 (W7)
  static const char css[] = 
    ""<style type=\\""text/css\\"">"" ""\\n""
    ""<!--"" ""\\n""
    "".xflip {"" ""\\n""
    ""    -moz-transform: scaleX(-1);"" ""\\n""
    ""    -webkit-transform: scaleX(-1);"" ""\\n""
    ""    -o-transform: scaleX(-1);"" ""\\n""
    ""    transform: scaleX(-1);"" ""\\n""
    ""    filter: fliph;"" ""\\n""
    ""}"" ""\\n""
    "".yflip {"" ""\\n""
    ""    -moz-transform: scaleY(-1);"" ""\\n""
    ""    -webkit-transform: scaleY(-1);"" ""\\n""
    ""    -o-transform: scaleY(-1);"" ""\\n""
    ""    transform: scaleY(-1);"" ""\\n""
    ""    filter: flipv;"" ""\\n""
    ""}"" ""\\n""
    "".xyflip {"" ""\\n""
    ""    -moz-transform: scaleX(-1) scaleY(-1);"" ""\\n""
    ""    -webkit-transform: scaleX(-1) scaleY(-1);"" ""\\n""
    ""    -o-transform: scaleX(-1) scaleY(-1);"" ""\\n""
    ""    transform: scaleX(-1) scaleY(-1);"" ""\\n""
    ""    filter: fliph + flipv;"" ""\\n""
    ""}"" ""\\n""
    ""-->"" ""\\n""
    ""</style>"" ""\\n"";

  fwrite( css, sizeof(css)-1, 1, f );
}

int HtmlPage::dumpComplexHeaders(FILE * const file, FILE *& pageFile, int page) {
  GooString* tmp;

  if( !noframes )
  {
      GooString* pgNum=GooString::fromInt(page);
      tmp = new GooString(DocName);
      if (!singleHtml){
            tmp->append('-')->append(pgNum)->append("".html"");
            pageFile = fopen(tmp->getCString(), ""w"");
      } else {
            tmp->append(""-html"")->append("".html"");
            pageFile = fopen(tmp->getCString(), ""a"");
      }
      delete pgNum;
      if (!pageFile) {
	  error(errIO, -1, ""Couldn't open html file '{0:t}'"", tmp);
	  delete tmp;
	  return 1;
      } 

      if (!singleHtml)
        fprintf(pageFile,""%s\\n<html xmlns=\\""http://www.w3.org/1999/xhtml\\"" lang=\\""\\"" xml:lang=\\""\\"">\\n<head>\\n<title>Page %d</title>\\n\\n"", DOCTYPE, page);
      else
        fprintf(pageFile,""%s\\n<html xmlns=\\""http://www.w3.org/1999/xhtml\\"" lang=\\""\\"" xml:lang=\\""\\"">\\n<head>\\n<title>%s</title>\\n\\n"", DOCTYPE, tmp->getCString());

      delete tmp;

      GooString *htmlEncoding = HtmlOutputDev::mapEncodingToHtml(globalParams->getTextEncodingName());
      if (!singleHtml)
        fprintf(pageFile, ""<meta http-equiv=\\""Content-Type\\"" content=\\""text/html; charset=%s\\""/>\\n"", htmlEncoding->getCString());
      else
        fprintf(pageFile, ""<meta http-equiv=\\""Content-Type\\"" content=\\""text/html; charset=%s\\""/>\\n <br/>\\n"", htmlEncoding->getCString());
      delete htmlEncoding;
  }
  else 
  {
      pageFile = file;
      fprintf(pageFile,""<!-- Page %d -->\\n"", page);
      fprintf(pageFile,""<a name=\\""%d\\""></a>\\n"", page);
  } 
  
  return 0;
}

void HtmlPage::dumpComplex(FILE *file, int page){
  FILE* pageFile;
  GooString* tmp;

  if( firstPage == -1 ) firstPage = page; 
  
  if (dumpComplexHeaders(file, pageFile, page)) { error(errIO, -1, ""Couldn't write headers.""); return; }

  tmp=basename(DocName);
   
  fputs(""<style type=\\""text/css\\"">\\n<!--\\n"",pageFile);
  fputs(""\\tp {margin: 0; padding: 0;}"",pageFile);
  for(int i=fontsPageMarker;i!=fonts->size();i++) {
    GooString *fontCSStyle;
    if (!singleHtml)
         fontCSStyle = fonts->CSStyle(i);
    else
         fontCSStyle = fonts->CSStyle(i,page);
    fprintf(pageFile,""\\t%s\\n"",fontCSStyle->getCString());
    delete fontCSStyle;
  }
 
  fputs(""-->\\n</style>\\n"",pageFile);
  
  if( !noframes )
  {  
      fputs(""</head>\\n<body bgcolor=\\""#A0A0A0\\"" vlink=\\""blue\\"" link=\\""blue\\"">\\n"",pageFile); 
  }
  
  fprintf(pageFile,""<div id=\\""page%d-div\\"" style=\\""position:relative;width:%dpx;height:%dpx;\\"">\\n"",
      page, pageWidth, pageHeight);

  if( !ignore ) 
  {
    fprintf(pageFile,
	    ""<img width=\\""%d\\"" height=\\""%d\\"" src=\\""%s%03d.%s\\"" alt=\\""background image\\""/>\\n"",
	    pageWidth, pageHeight, tmp->getCString(), 
		(page-firstPage+1), imgExt->getCString());
  }
  
  delete tmp;
  
  for(HtmlString *tmp1=yxStrings;tmp1;tmp1=tmp1->yxNext){
    if (tmp1->htext){
      fprintf(pageFile,
	      ""<p style=\\""position:absolute;top:%dpx;left:%dpx;white-space:nowrap\\"" class=\\""ft"",
	      xoutRound(tmp1->yMin),
	      xoutRound(tmp1->xMin));
      if (!singleHtml) {
          fputc('0', pageFile);
      } else {
          fprintf(pageFile, ""%d"", page);
      }
      fprintf(pageFile,""%d\\"">"", tmp1->fontpos);
      fputs(tmp1->htext->getCString(), pageFile);
      fputs(""</p>\\n"", pageFile);
    }
  }

  fputs(""</div>\\n"", pageFile);
  
  if( !noframes )
  {
      fputs(""</body>\\n</html>\\n"",pageFile);
      fclose(pageFile);
  }
}


void HtmlPage::dump(FILE *f, int pageNum) 
{
  if (complexMode || singleHtml)
  {
    if (xml) dumpAsXML(f, pageNum);
    if (!xml) dumpComplex(f, pageNum);  
  }
  else
  {
    fprintf(f,""<a name=%d></a>"",pageNum);
    // Loop over the list of image names on this page
    int listlen=imgList->getLength();
    for (int i = 0; i < listlen; i++) {
      HtmlImage *img = (HtmlImage*)imgList->del(0);

      // see printCSS() for class names
      const char *styles[4] = { """", "" class=\\""xflip\\"""", "" class=\\""yflip\\"""", "" class=\\""xyflip\\"""" };
      int style_index=0;
      if (img->xMin > img->xMax) style_index += 1; // xFlip
      if (img->yMin > img->yMax) style_index += 2; // yFlip

      fprintf(f,""<img%s src=\\""%s\\""/><br/>\\n"",styles[style_index],img->fName->getCString());
      delete img;
    }

    GooString* str;
    for(HtmlString *tmp=yxStrings;tmp;tmp=tmp->yxNext){
      if (tmp->htext){
		str=new GooString(tmp->htext); 
		fputs(str->getCString(),f);
		delete str;      
		fputs(""<br/>\\n"",f);
      }
    }
	fputs(""<hr/>\\n"",f);  
  }
}



void HtmlPage::clear() {
  HtmlString *p1, *p2;

  if (curStr) {
    delete curStr;
    curStr = NULL;
  }
  for (p1 = yxStrings; p1; p1 = p2) {
    p2 = p1->yxNext;
    delete p1;
  }
  yxStrings = NULL;
  xyStrings = NULL;
  yxCur1 = yxCur2 = NULL;

  if( !noframes )
  {
      delete fonts;
      fonts=new HtmlFontAccu();
      fontsPageMarker = 0;
  }
  else
  {
      fontsPageMarker = fonts->size();
  }

  delete links;
  links=new HtmlLinks();
 

}

void HtmlPage::setDocName(char *fname){
  DocName=new GooString(fname);
}

void HtmlPage::addImage(GooString *fname, GfxState *state) {
  HtmlImage *img = new HtmlImage(fname, state);
  imgList->append(img);
}

//------------------------------------------------------------------------
// HtmlMetaVar
//------------------------------------------------------------------------

HtmlMetaVar::HtmlMetaVar(const char *_name, const char *_content)
{
    name = new GooString(_name);
    content = new GooString(_content);
}

HtmlMetaVar::~HtmlMetaVar()
{
   delete name;
   delete content;
} 
    
GooString* HtmlMetaVar::toString()	
{
    GooString *result = new GooString(""<meta name=\\"""");
    result->append(name);
    result->append(""\\"" content=\\"""");
    result->append(content);
    result->append(""\\""/>"");
    return result;
}

//------------------------------------------------------------------------
// HtmlOutputDev
//------------------------------------------------------------------------

static const char* HtmlEncodings[][2] = {
    {""Latin1"", ""ISO-8859-1""},
    {NULL, NULL}
};

GooString* HtmlOutputDev::mapEncodingToHtml(GooString* encoding)
{
  GooString* enc = encoding;
  for(int i = 0; HtmlEncodings[i][0] != NULL; i++)
  {
    if( enc->cmp(HtmlEncodings[i][0]) == 0 )
    {
      delete enc;
      return new GooString(HtmlEncodings[i][1]);
    }
  }
  return enc; 
}

void HtmlOutputDev::doFrame(int firstPage){
  GooString* fName=new GooString(Docname);
  GooString* htmlEncoding;
  fName->append("".html"");

  if (!(fContentsFrame = fopen(fName->getCString(), ""w""))){
    error(errIO, -1, ""Couldn't open html file '{0:t}'"", fName);
    delete fName;
    return;
  }
  
  delete fName;
    
  fName=basename(Docname);
  fputs(DOCTYPE, fContentsFrame);
  fputs(""\\n<html>"",fContentsFrame);
  fputs(""\\n<head>"",fContentsFrame);
  fprintf(fContentsFrame,""\\n<title>%s</title>"",docTitle->getCString());
  htmlEncoding = mapEncodingToHtml(globalParams->getTextEncodingName());
  fprintf(fContentsFrame, ""\\n<meta http-equiv=\\""Content-Type\\"" content=\\""text/html; charset=%s\\""/>\\n"", htmlEncoding->getCString());
  dumpMetaVars(fContentsFrame);
  fprintf(fContentsFrame, ""</head>\\n"");
  fputs(""<frameset cols=\\""100,*\\"">\\n"",fContentsFrame);
  fprintf(fContentsFrame,""<frame name=\\""links\\"" src=\\""%s_ind.html\\""/>\\n"",fName->getCString());
  fputs(""<frame name=\\""contents\\"" src="",fContentsFrame); 
  if (complexMode) 
      fprintf(fContentsFrame,""\\""%s-%d.html\\"""",fName->getCString(), firstPage);
  else
      fprintf(fContentsFrame,""\\""%ss.html\\"""",fName->getCString());
  
  fputs(""/>\\n</frameset>\\n</html>\\n"",fContentsFrame);
 
  delete fName;
  delete htmlEncoding;
  fclose(fContentsFrame);  
}

HtmlOutputDev::HtmlOutputDev(Catalog *catalogA, char *fileName, char *title, 
	char *author, char *keywords, char *subject, char *date,
	char *extension,
	GBool rawOrder, int firstPage, GBool outline) 
{
  catalog = catalogA;
  fContentsFrame = NULL;
  docTitle = new GooString(title);
  pages = NULL;
  dumpJPEG=gTrue;
  //write = gTrue;
  this->rawOrder = rawOrder;
  this->doOutline = outline;
  ok = gFalse;
  //this->firstPage = firstPage;
  //pageNum=firstPage;
  // open file
  needClose = gFalse;
  pages = new HtmlPage(rawOrder, extension);
  
  glMetaVars = new GooList();
  glMetaVars->append(new HtmlMetaVar(""generator"", ""pdftohtml 0.36""));  
  if( author ) glMetaVars->append(new HtmlMetaVar(""author"", author));  
  if( keywords ) glMetaVars->append(new HtmlMetaVar(""keywords"", keywords));  
  if( date ) glMetaVars->append(new HtmlMetaVar(""date"", date));  
  if( subject ) glMetaVars->append(new HtmlMetaVar(""subject"", subject));
 
  maxPageWidth = 0;
  maxPageHeight = 0;

  pages->setDocName(fileName);
  Docname=new GooString (fileName);

  // for non-xml output (complex or simple) with frames generate the left frame
  if(!xml && !noframes)
  {
     if (!singleHtml)
     {
         GooString* left=new GooString(fileName);
         left->append(""_ind.html"");

         doFrame(firstPage);

         if (!(fContentsFrame = fopen(left->getCString(), ""w"")))
         {
             error(errIO, -1, ""Couldn't open html file '{0:t}'"", left);
             delete left;
             return;
         }
         delete left;
         fputs(DOCTYPE, fContentsFrame);
         fputs(""<html xmlns=\\""http://www.w3.org/1999/xhtml\\"" lang=\\""\\"" xml:lang=\\""\\"">\\n<head>\\n<title></title>\\n</head>\\n<body>\\n"", fContentsFrame);

         if (doOutline)
         {
             GooString *str = basename(Docname);
             fprintf(fContentsFrame, ""<a href=\\""%s%s\\"" target=\\""contents\\"">Outline</a><br/>"", str->getCString(), complexMode ? ""-outline.html"" : ""s.html#outline"");
             delete str;
         }
     }
	if (!complexMode)
	{	/* not in complex mode */
		
       GooString* right=new GooString(fileName);
       right->append(""s.html"");

       if (!(page=fopen(right->getCString(),""w""))){
        error(errIO, -1, ""Couldn't open html file '{0:t}'"", right);
        delete right;
		return;
       }
       delete right;
       fputs(DOCTYPE, page);
       fputs(""<html>\\n<head>\\n<title></title>\\n"",page);
       printCSS(page);
       fputs(""</head>\\n<body>\\n"",page);
     }
  }

  if (noframes) {
    if (stout) page=stdout;
    else {
      GooString* right=new GooString(fileName);
      if (!xml) right->append("".html"");
      if (xml) right->append("".xml"");
      if (!(page=fopen(right->getCString(),""w""))){
	error(errIO, -1, ""Couldn't open html file '{0:t}'"", right);
	delete right;
	return;
      }  
      delete right;
    }

    GooString *htmlEncoding = mapEncodingToHtml(globalParams->getTextEncodingName()); 
    if (xml) 
    {
      fprintf(page, ""<?xml version=\\""1.0\\"" encoding=\\""%s\\""?>\\n"", htmlEncoding->getCString());
      fputs(""<!DOCTYPE pdf2xml SYSTEM \\""pdf2xml.dtd\\"">\\n\\n"", page);
      fprintf(page,""<pdf2xml producer=\\""%s\\"" version=\\""%s\\"">\\n"", PACKAGE_NAME, PACKAGE_VERSION);
    } 
    else 
    {
      fprintf(page,""%s\\n<html xmlns=\\""http://www.w3.org/1999/xhtml\\"" lang=\\""\\"" xml:lang=\\""\\"">\\n<head>\\n<title>%s</title>\\n"", DOCTYPE, docTitle->getCString());
      
      fprintf(page, ""<meta http-equiv=\\""Content-Type\\"" content=\\""text/html; charset=%s\\""/>\\n"", htmlEncoding->getCString());
      
      dumpMetaVars(page);
      printCSS(page);
      fprintf(page,""</head>\\n"");
      fprintf(page,""<body bgcolor=\\""#A0A0A0\\"" vlink=\\""blue\\"" link=\\""blue\\"">\\n"");
    }
    delete htmlEncoding;
  }
  ok = gTrue; 
}

HtmlOutputDev::~HtmlOutputDev() {
    HtmlFont::clear(); 
    
    delete Docname;
    delete docTitle;

    deleteGooList(glMetaVars, HtmlMetaVar);

    if (fContentsFrame){
      fputs(""</body>\\n</html>\\n"",fContentsFrame);  
      fclose(fContentsFrame);
    }
    if (page != NULL) {
      if (xml) {
        fputs(""</pdf2xml>\\n"",page);  
        fclose(page);
      } else
      if ( !complexMode || xml || noframes )
      { 
        fputs(""</body>\\n</html>\\n"",page);  
        fclose(page);
      }
    }
    if (pages)
      delete pages;
}

void HtmlOutputDev::startPage(int pageNum, GfxState *state, XRef *xref) {
#if 0
  if (mode&&!xml){
    if (write){
      write=gFalse;
      GooString* fname=Dirname(Docname);
      fname->append(""image.log"");
      if((tin=fopen(getFileNameFromPath(fname->getCString(),fname->getLength()),""w""))==NULL){
	printf(""Error : can not open %s"",fname);
	exit(1);
      }
      delete fname;
    // if(state->getRotation()!=0) 
    //  fprintf(tin,""ROTATE=%d rotate %d neg %d neg translate\\n"",state->getRotation(),state->getX1(),-state->getY1());
    // else 
      fprintf(tin,""ROTATE=%d neg %d neg translate\\n"",state->getX1(),state->getY1());  
    }
  }
#endif

  this->pageNum = pageNum;
  GooString *str=basename(Docname);
  pages->clear(); 
  if(!noframes)
  {
    if (fContentsFrame)
	{
      if (complexMode)
		fprintf(fContentsFrame,""<a href=\\""%s-%d.html\\"""",str->getCString(),pageNum);
      else 
		fprintf(fContentsFrame,""<a href=\\""%ss.html#%d\\"""",str->getCString(),pageNum);
      fprintf(fContentsFrame,"" target=\\""contents\\"" >Page %d</a><br/>\\n"",pageNum);
    }
  }

  pages->pageWidth=static_cast<int>(state->getPageWidth());
  pages->pageHeight=static_cast<int>(state->getPageHeight());

  delete str;
} 


void HtmlOutputDev::endPage() {
  Links *linksList = docPage->getLinks();
  for (int i = 0; i < linksList->getNumLinks(); ++i)
  {
      doProcessLink(linksList->getLink(i));
  }
  delete linksList;

  pages->conv();
  pages->coalesce();
  pages->dump(page, pageNum);
  
  // I don't yet know what to do in the case when there are pages of different
  // sizes and we want complex output: running ghostscript many times 
  // seems very inefficient. So for now I'll just use last page's size
  maxPageWidth = pages->pageWidth;
  maxPageHeight = pages->pageHeight;
  
  //if(!noframes&&!xml) fputs(""<br/>\\n"", fContentsFrame);
  if(!stout && !globalParams->getErrQuiet()) printf(""Page-%d\\n"",(pageNum));
}

void HtmlOutputDev::updateFont(GfxState *state) {
  pages->updateFont(state);
}

void HtmlOutputDev::beginString(GfxState *state, GooString *s) {
  pages->beginString(state, s);
}

void HtmlOutputDev::endString(GfxState *state) {
  pages->endString();
}

void HtmlOutputDev::drawChar(GfxState *state, double x, double y,
	      double dx, double dy,
	      double originX, double originY,
	      CharCode code, int /*nBytes*/, Unicode *u, int uLen) 
{
  if ( !showHidden && (state->getRender() & 3) == 3) {
    return;
  }
  pages->addChar(state, x, y, dx, dy, originX, originY, u, uLen);
}

void HtmlOutputDev::drawJpegImage(GfxState *state, Stream *str)
{
  FILE *f1;
  int c;

  // open the image file
  GooString *fName=createImageFileName(""jpg"");
  if (!(f1 = fopen(fName->getCString(), ""wb""))) {
    error(errIO, -1, ""Couldn't open image file '%s'"", fName->getCString());
    delete fName;
    return;
  }

  // initialize stream
  str = str->getNextStream();
  str->reset();

  // copy the stream
  while ((c = str->getChar()) != EOF)
    fputc(c, f1);

  fclose(f1);

  if (fName) {
      pages->addImage(fName, state);
  }
}

void HtmlOutputDev::drawPngImage(GfxState *state, Stream *str, int width, int height,
                                 GfxImageColorMap *colorMap, GBool isMask)
{
#ifdef ENABLE_LIBPNG
  FILE *f1;

  if (!colorMap && !isMask) {
    error(errInternal, -1, ""Can't have color image without a color map"");
    return;
  }

  // open the image file
  GooString *fName=createImageFileName(""png"");
  if (!(f1 = fopen(fName->getCString(), ""wb""))) {
    error(errIO, -1, ""Couldn't open image file '%s'"", fName->getCString());
    delete fName;
    return;
  }

  PNGWriter *writer = new PNGWriter( isMask ? PNGWriter::MONOCHROME : PNGWriter::RGB );
  // TODO can we calculate the resolution of the image?
  if (!writer->init(f1, width, height, 72, 72)) {
    error(errInternal, -1, ""Can't init PNG for image '%s'"", fName->getCString());
    delete writer;
    fclose(f1);
    return;
  }

  if (!isMask) {
    Guchar *p;
    GfxRGB rgb;
    png_byte *row = (png_byte *) gmalloc(3 * width);   // 3 bytes/pixel: RGB
    png_bytep *row_pointer= &row;

    // Initialize the image stream
    ImageStream *imgStr = new ImageStream(str, width,
                        colorMap->getNumPixelComps(), colorMap->getBits());
    imgStr->reset();

    // For each line...
    for (int y = 0; y < height; y++) {

      // Convert into a PNG row
      p = imgStr->getLine();
      for (int x = 0; x < width; x++) {
        colorMap->getRGB(p, &rgb);
        // Write the RGB pixels into the row
        row[3*x]= colToByte(rgb.r);
        row[3*x+1]= colToByte(rgb.g);
        row[3*x+2]= colToByte(rgb.b);
        p += colorMap->getNumPixelComps();
      }

      if (!writer->writeRow(row_pointer)) {
        error(errIO, -1, ""Failed to write into PNG '%s'"", fName->getCString());
        delete writer;
        delete imgStr;
        fclose(f1);
        return;
      }
    }
    gfree(row);
    imgStr->close();
    delete imgStr;
  }
  else { // isMask == true
    ImageStream *imgStr = new ImageStream(str, width, 1, 1);
    imgStr->reset();

    Guchar *png_row = (Guchar *)gmalloc( width );

    for (int ri = 0; ri < height; ++ri)
    {
      // read the row of the mask
      Guchar *bit_row = imgStr->getLine();

      // invert for PNG
      for(int i = 0; i < width; i++)
        png_row[i] = bit_row[i] ? 0xff : 0x00;

      if (!writer->writeRow( &png_row ))
      {
        error(errIO, -1, ""Failed to write into PNG '%s'"", fName->getCString());
        delete writer;
        fclose(f1);
        delete imgStr;
        gfree(png_row);
        return;
      }
    }
    imgStr->close();
    delete imgStr;
    gfree(png_row);
  }

  str->close();

  writer->close();
  delete writer;
  fclose(f1);

  pages->addImage(fName, state);
#else
  return;
#endif
}

GooString *HtmlOutputDev::createImageFileName(const char *ext)
{
  GooString *fName=new GooString(Docname);
  fName->append(""-"");
  GooString *pgNum= GooString::fromInt(pageNum);
  GooString *imgnum= GooString::fromInt(pages->getNumImages()+1);

  fName->append(pgNum)->append(""_"")->append(imgnum)->append(""."")->append(ext);
  delete pgNum;
  delete imgnum;

  return fName;
}

void HtmlOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str,
				  int width, int height, GBool invert,
				  GBool interpolate, GBool inlineImg) {

  if (ignore||(complexMode && !xml)) {
    OutputDev::drawImageMask(state, ref, str, width, height, invert, interpolate, inlineImg);
    return;
  }
  
  // dump JPEG file
  if (dumpJPEG  && str->getKind() == strDCT) {
    drawJpegImage(state, str);
  }
  else {
#ifdef ENABLE_LIBPNG
    drawPngImage(state, str, width, height, NULL, gTrue);
#else
    OutputDev::drawImageMask(state, ref, str, width, height, invert, interpolate, inlineImg);
#endif
  }
}

void HtmlOutputDev::drawImage(GfxState *state, Object *ref, Stream *str,
			      int width, int height, GfxImageColorMap *colorMap,
			      GBool interpolate, int *maskColors, GBool inlineImg) {

  if (ignore||(complexMode && !xml)) {
    OutputDev::drawImage(state, ref, str, width, height, colorMap, interpolate,
			 maskColors, inlineImg);
    return;
  }
  
  /*if( !globalParams->getErrQuiet() )
    printf(""image stream of kind %d\\n"", str->getKind());*/
  // dump JPEG file
  if (dumpJPEG && str->getKind() == strDCT && (colorMap->getNumPixelComps() == 1 ||
	  colorMap->getNumPixelComps() == 3) && !inlineImg) {
    drawJpegImage(state, str);
  }
  else {
#ifdef ENABLE_LIBPNG
    drawPngImage(state, str, width, height, colorMap );
#else
    OutputDev::drawImage(state, ref, str, width, height, colorMap, interpolate,
                         maskColors, inlineImg);
#endif
  }
}



void HtmlOutputDev::doProcessLink(AnnotLink* link){
  double _x1,_y1,_x2,_y2;
  int x1,y1,x2,y2;

  link->getRect(&_x1,&_y1,&_x2,&_y2);
  cvtUserToDev(_x1,_y1,&x1,&y1);
  
  cvtUserToDev(_x2,_y2,&x2,&y2); 


  GooString* _dest=getLinkDest(link);
  HtmlLink t((double) x1,(double) y2,(double) x2,(double) y1,_dest);
  pages->AddLink(t);
  delete _dest;
}

GooString* HtmlOutputDev::getLinkDest(AnnotLink *link){
  char *p;
  if (!link->getAction())
    return new GooString();
  switch(link->getAction()->getKind()) 
  {
      case actionGoTo:
	  { 
	  GooString* file=basename(Docname);
	  int page=1;
	  LinkGoTo *ha=(LinkGoTo *)link->getAction();
	  LinkDest *dest=NULL;
	  if (ha->getDest()!=NULL)
	      dest=ha->getDest()->copy();
	  else if (ha->getNamedDest()!=NULL)
	      dest=catalog->findDest(ha->getNamedDest());
	      
	  if (dest){ 
	      if (dest->isPageRef()){
		  Ref pageref=dest->getPageRef();
		  page=catalog->findPage(pageref.num,pageref.gen);
	      }
	      else {
		  page=dest->getPageNum();
	      }

	      delete dest;

	      GooString *str=GooString::fromInt(page);
	      /* 		complex 	simple
	       	frames		file-4.html	files.html#4
		noframes	file.html#4	file.html#4
	       */
	      if (noframes)
	      {
		  file->append("".html#"");
		  file->append(str);
	      }
	      else
	      {
	      	if( complexMode ) 
		{
		    file->append(""-"");
		    file->append(str);
		    file->append("".html"");
		}
		else
		{
		    file->append(""s.html#"");
		    file->append(str);
		}
	      }

	      if (printCommands) printf("" link to page %d "",page);
	      delete str;
	      return file;
	  }
	  else 
	  {
	      return new GooString();
	  }
	  }
      case actionGoToR:
	  {
	  LinkGoToR *ha=(LinkGoToR *) link->getAction();
	  LinkDest *dest=NULL;
	  int page=1;
	  GooString *file=new GooString();
	  if (ha->getFileName()){
	      delete file;
	      file=new GooString(ha->getFileName()->getCString());
	  }
	  if (ha->getDest()!=NULL)  dest=ha->getDest()->copy();
	  if (dest&&file){
	      if (!(dest->isPageRef()))  page=dest->getPageNum();
	      delete dest;

	      if (printCommands) printf("" link to page %d "",page);
	      if (printHtml){
		  p=file->getCString()+file->getLength()-4;
		  if (!strcmp(p, "".pdf"") || !strcmp(p, "".PDF"")){
		      file->del(file->getLength()-4,4);
		      file->append("".html"");
		  }
		  file->append('#');
		  file->append(GooString::fromInt(page));
	      }
	  }
	  if (printCommands && file) printf(""filename %s\\n"",file->getCString());
	  return file;
	  }
      case actionURI:
	  { 
	  LinkURI *ha=(LinkURI *) link->getAction();
	  GooString* file=new GooString(ha->getURI()->getCString());
	  // printf(""uri : %s\\n"",file->getCString());
	  return file;
	  }
      case actionLaunch:
	  {
	  LinkLaunch *ha=(LinkLaunch *) link->getAction();
	  GooString* file=new GooString(ha->getFileName()->getCString());
	  if (printHtml) { 
	      p=file->getCString()+file->getLength()-4;
	      if (!strcmp(p, "".pdf"") || !strcmp(p, "".PDF"")){
		  file->del(file->getLength()-4,4);
		  file->append("".html"");
	      }
	      if (printCommands) printf(""filename %s"",file->getCString());
    
	      return file;      
  
	  }
	  }
      default:
	  return new GooString();
  }
}

void HtmlOutputDev::dumpMetaVars(FILE *file)
{
  GooString *var;

  for(int i = 0; i < glMetaVars->getLength(); i++)
  {
     HtmlMetaVar *t = (HtmlMetaVar*)glMetaVars->get(i); 
     var = t->toString(); 
     fprintf(file, ""%s\\n"", var->getCString());
     delete var;
  }
}

GBool HtmlOutputDev::dumpDocOutline(PDFDoc* doc)
{ 
#ifdef DISABLE_OUTLINE
	return gFalse;
#else
	FILE * output = NULL;
	GBool bClose = gFalse;
	Catalog *catalog = doc->getCatalog();

	if (!ok)
                return gFalse;
  
	Outline *outline = doc->getOutline();
	if (!outline)
		return gFalse;

	GooList *outlines = outline->getItems();
	if (!outlines)
		return gFalse;
  
	if (!complexMode || xml)
  	{
		output = page;
  	}
  	else if (complexMode && !xml)
	{
		if (noframes)
		{
			output = page; 
			fputs(""<hr/>\\n"", output);
		}
		else
		{
			GooString *str = Docname->copy();
			str->append(""-outline.html"");
			output = fopen(str->getCString(), ""w"");
			delete str;
			if (output == NULL)
				return gFalse;
			bClose = gTrue;

			GooString *htmlEncoding =
				HtmlOutputDev::mapEncodingToHtml(globalParams->getTextEncodingName());

			fprintf(output, ""<html xmlns=\\""http://www.w3.org/1999/xhtml\\"" "" \\
                                ""lang=\\""\\"" xml:lang=\\""\\"">\\n""            \\
                                ""<head>\\n""                              \\
                                ""<title>Document Outline</title>\\n""     \\
                                ""<meta http-equiv=\\""Content-Type\\"" content=\\""text/html; "" \\
                                ""charset=%s\\""/>\\n""                      \\
                                ""</head>\\n<body>\\n"", htmlEncoding->getCString());
			delete htmlEncoding;
		}
	}
 
	if (!xml)
	{
		GBool done = newHtmlOutlineLevel(output, outlines, catalog);
		if (done && !complexMode)
			fputs(""<hr/>\\n"", output);
	
		if (bClose)
		{
			fputs(""</body>\\n</html>\\n"", output);
			fclose(output);
		}
	}
	else
		newXmlOutlineLevel(output, outlines, catalog);

	return gTrue;
#endif
}

GBool HtmlOutputDev::newHtmlOutlineLevel(FILE *output, GooList *outlines, Catalog* catalog, int level)
{
#ifdef DISABLE_OUTLINE
	return gFalse;
#else
	GBool atLeastOne = gFalse;

	if (level == 1)
	{
		fputs(""<a name=\\""outline\\""></a>"", output);
		fputs(""<h1>Document Outline</h1>\\n"", output);
	}
	fputs(""<ul>\\n"",output);

	for (int i = 0; i < outlines->getLength(); i++)
	{
		OutlineItem *item = (OutlineItem*)outlines->get(i);
		GooString *titleStr = HtmlFont::HtmlFilter(item->getTitle(),
							   item->getTitleLength());

		GooString *linkName = NULL;;
        int page = getOutlinePageNum(item);
        if (page > 0)
        {
				/*		complex		simple
				frames		file-4.html	files.html#4
				noframes	file.html#4	file.html#4
				*/
				linkName=basename(Docname);
				GooString *str=GooString::fromInt(page);
				if (noframes) {
					linkName->append("".html#"");
					linkName->append(str);
				} else {
					if( complexMode ) {
						linkName->append(""-"");
						linkName->append(str);
						linkName->append("".html"");
					} else {
						linkName->append(""s.html#"");
						linkName->append(str);
					}
				}
				delete str;
		}

		fputs(""<li>"",output);
		if (linkName)
			fprintf(output,""<a href=\\""%s\\"">"", linkName->getCString());
		fputs(titleStr->getCString(),output);
		if (linkName) {
			fputs(""</a>"",output);
			delete linkName;
		}
		delete titleStr;
		atLeastOne = gTrue;

		item->open();
		if (item->hasKids() && item->getKids())
		{
			fputs(""\\n"",output);
			newHtmlOutlineLevel(output, item->getKids(), catalog, level+1);
		}
		item->close();
		fputs(""</li>\\n"",output);
	}
	fputs(""</ul>\\n"",output);

	return atLeastOne;
#endif
}

void HtmlOutputDev::newXmlOutlineLevel(FILE *output, GooList *outlines, Catalog* catalog)
{
#ifndef DISABLE_OUTLINE
    fputs(""<outline>\\n"", output);

    for (int i = 0; i < outlines->getLength(); i++)
    {
        OutlineItem *item     = (OutlineItem*)outlines->get(i);
        GooString   *titleStr = HtmlFont::HtmlFilter(item->getTitle(),
                                                     item->getTitleLength());
        int page = getOutlinePageNum(item);
        if (page > 0)
        {
            fprintf(output, ""<item page=\\""%d\\"">%s</item>\\n"",
                    page, titleStr->getCString());
        }
        else
        {
            fprintf(output, ""<item>%s</item>\\n"", titleStr->getCString());
        }
        delete titleStr;

        item->open();
        if (item->hasKids() && item->getKids())
        {
            newXmlOutlineLevel(output, item->getKids(), catalog);
        }
        item->close();
    }    

    fputs(""</outline>\\n"", output);
#endif
}

#ifndef DISABLE_OUTLINE
int HtmlOutputDev::getOutlinePageNum(OutlineItem *item)
{
    LinkAction *action   = item->getAction();
    LinkGoTo   *link     = NULL;
    LinkDest   *linkdest = NULL;
    int         pagenum  = -1;

    if (!action || action->getKind() != actionGoTo)
        return pagenum;

    link = dynamic_cast<LinkGoTo*>(action);

    if (!link || !link->isOk())
        return pagenum;

    if (link->getDest())
        linkdest = link->getDest()->copy();
    else if (link->getNamedDest())
        linkdest = catalog->findDest(link->getNamedDest());

    if (!linkdest)
        return pagenum;

    if (linkdest->isPageRef()) {
        Ref pageref = linkdest->getPageRef();
        pagenum = catalog->findPage(pageref.num, pageref.gen);
    } else {
        pagenum = linkdest->getPageNum();
    }

    delete linkdest;
    return pagenum;
}
#endif
",16360,True,2526.1967848000177,median
"= ModPlan v1.4 - Developer's 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:
endif::[]
:repoURL: https://github.com/AY1920S1-CS2113T-F10-1/main

By: `Team AY1920S1-CS2113T-F10-1`      Since: `Aug 2019`      License: `MIT`

== Introduction

*ModPlan*

ModPlan is a module planning system that expands on NUSMODS to help NUS students to plan their modules for all four years of their bachelor’s degree.  +

ModPlan is currently only designed to work for Computer Engineering students, and the requisite modules for graduation.

ModPlan uses NUSMODS API to extract official module data from the NUS Registrar's Office. + 

This Developer Guide is meant for anyone who wishes to contribute to ModPlan further, and serves to guide them through the architecture,
implementation methods and high-level design considerations taken during our current development.

== Setting up

**Prerequisites**

* JDK version:  https://www.oracle.com/technetwork/java/javase/downloads/jdk11-downloads-5066655.html[`11`] or above
* Recommended IDE: https://www.jetbrains.com/idea/[`IntelliJ IDEA`]
* Fork this repo to your https://github.com/[GitHub account] and clone the fork to your computer

**Importing the project into IntelliJ**

1. Open IntelliJ (if you are not in the welcome screen, click `File` > `Close Project` to close the existing project dialog first).
2. Set up the correct JDK version.
   * Click `Configure` > `Structure for new Projects` (in older versions of Intellij:`Configure` > `Project Defaults` > `Project Structure`).
   * If JDK 11 is listed in the drop down, select it. If it is not, click `New...` and select the directory where you installed JDK 11.
   * Click `OK`.
3. Click `Import Project`.
4. Locate the project directory and click `OK`.
5. Select `Create project from existing sources` and click `Next`.
6. Rename the project if you want. Click `Next`.
7. Ensure that your src folder is checked. Keep clicking `Next`.
8. Click `Finish`.

**Running the Project**

* If you wish to run the `Jar` file, simply run the command `java -jar [CS2113T-F10-1][ModPlan].jar` in any terminal application
of your choice.

*This is assumes that JDK version `11` and above is installed.*

* If you are not using `gradle`, simply locate the `CliLauncher.java` file under `PROJECT_DIRECTORY/src/main/java/planner/main/CliLauncher.java`, and run it in your IDE.

* If you are using `gradle`, import the project as a gradle project using the `Import Gradle Project` function in IntelliJ, and run `gradlew run` from the command line.

== Overall Design

=== Architecture

Our integration approach would be bottom-up, as some of the components we have utilised from a previous project can be adapted and reused of other purposes. +

In that way, our implementation approach would also be incremental as oppose to big-bang, since we would need to gradually alter and test out which portions of Duke is reusable in ModPlan.

The *architecture diagram* of ModPlan can be seen in the below diagram, where it shows the high-level architecture design of our project:

image::architecture.png[]

As seen here, the user interacts with the *Parser* through the command line interface (CLI), which sorts through the user input and calls various commands under the *Command* section. 

The classes within *Command* will then utilise data pulled from the *Storage* and *JsonWrapper*, who pull data both locally as well as from NUSMODS API through the *RequestData*.

Following which, the *Command* classes perform their execution of the feature, and update the *Storage* to store data that has changed. It also shows the user the completed function by printing any necessary information/feedback to the user through the *PlannerUi*.

To read more about the various packages shown in the architecture diagram, please continue reading the below sections 
<<JsonWrapper>> 
<<Storage>> 
<<Parser>>
<<PlannerUi>> 
<<Command>> 
<<CCA>>.

=== JsonWrapper

The main wrapper over requesting data from NUSMODS API, Gson library for JSON parsing. Dependant on Storage class for writing data files obtained.

image::JsonWrapper.png[width=""350""]

This class is also dependant on a RequestData class which serves as the main API caller for ModPlanner, but it is not used anywhere else in the code base.

=== Storage

Main class which handles file writing during runtime and for maintaining user data in memory.

image::Storage.png[width=""350""]

This class was adapted from the existing Duke storage to suit the needs of ModPlanner.

[[Parser]]

=== Parser

Parser is implemented as `Parser` class (formerly named `Argparse4jWrapper`) which is a wrapper for the `argparse4j` library to handle user input and manage internal command mapping.

image::Parser.png[]

=== PlannerUi

The main class which handles user display, which includes reading user input and printing module, CAP and CCA information back to the user on command-line.

image::PlannerUi.png[]

=== Command

Commands are the main classes with which we execute our features. All of the specific `Command` classes inherit the base `ModuleCommand` abstract class, and utilize its `execute` method. 

The execute method takes in the detailed map of modules drawn from the NUSMODS API Json file, module task list, cca list, planner UI, storage, and the jsonWrapper parser. Each execute method is overriden in the specific Command classes to do what the feature requires of the class.

The `ModuleCommand` class also receives arguments based on the arguments passed by the `Parser` class, which is our main parser for the program, detailed above in <<Parser>>. +

These arguments change how some of the classes function as well, using a switch case system to sort through the different argument types received. These will changes will be explained further under the Implementation section here <<Implementation>>.

image::Command.png[]

The above diagram shows the various Command classes in ModPlan, as well as their depedencies (mostly on `ModuleCommand`).

=== CCA

CCA is implemented as `Cca` class which inherits from the legacy `TaskWithMultipleWeeklyPeriod`. It is the backbone for representing and managing user-defined CCAs. Typically, CCAs are loaded and stored in an `List`-like structure implemented in `TaskList<Cca>` class which inherits from `ArrayList<TaskWithMultipleWeeklyPeriod>`.

image::CCA.png[]

[[Implementation]]

== Implementation
This section explains and shows diagrams of how certain features of ModPlan are implemented.

// tag::Parser[]

=== Parser
User inputs are recorded by `PlannerUi` and then handled and interpreted by `Parser` class, which is a wrapper for the `argparse4j` library for customized parsing behaviours such as command calling or custom `Action` definition.

==== Current implementation

The following diagram illustrates the relation of `Parser` to various other core classes:

image::ParseCommandClassDiagram.png[]

[[Attributes]]

===== Attributes

`Parser` (formerly `Argparse4jWrapper`) relies on two major `private` variables `commandMapper` which has the type `HashMap<String, Class<? extends ModuleCommand>>` and `parser` which is an instance of `ArgumentParser`.

Additionally, `Parser` also has attribute `subParserManager` which is the `Subparsers` object associated with `parser` and `subParsers` which is of type `HashMap<String, Subparser>`. Any `Subparser` object added by `subParserManager` should be added to `subParser` as new value with its name as the key for ease of retrieval.

* `parser` is the parent parser for all user inputs, any commands implemented must be parsed using a `Subparser` object added by `subParserManager` as described above.

* `commandMapper` is the `HashMap` which maps the command name (which is often the same as the `subParser` 's name and the key in `subParser`) to the corresponding `ModuleCommand` class.

`Parser` also support custom `Action` objects for custom parsing behaviours which implementation and usage details can be found in `argparse4j` 's documentation.

===== Methods
There are several ""init"" methods which would be called on every new instance of `Parser`:

* `private void initBuiltinActions()` initializes all builtin `Action` objects necessary for normal parsing of builtin commands.

* `private void mapBuiltinCommands()` maps builtin commands and corresponding classes using `commandMapper` as described in <<Attributes>>.

* `private void initBuiltinParsers()` initializes all `Subparser` objects for builtin commands.

* `private void mapBuiltinParserArguments()` specifies all arguments and properties for `Subparser` objects generated by `initBuiltinParsers`.

===== Operation Overview
`Parser` provides several methods for parsing inputs:

* `parseCommand` takes in a `String` object as argument and returns an object that inherits from `ModuleCommand` (dynamic type) corresponding to the input received or `null` if the input is invalid. If any `ModuleCommand` object invoked `throw` a `ModException` object, the exception will be re-`throw`. Else, the corresponding `ModuleCommand` object is invoked by the `invokeCommand()` method This is the method used by `ModPlanner` to parse commands and invoke the corresponding `ModuleCommand` classes.

* `parse` returns a `Namespace` object containing all the parsed arguments instead. It has several overloaded implementations:

** `public Namespace parse(String[] args)`

** `public Namespace parse(String userInput)`

** `public Namespace parse(String subParserName, String[] args)`

** `public Namespace parse(String subParserName, String userInput)`

`subParserName`, if specified when calling, will tell `Parser` to look for the corresponding `Subparser` object associated with `parser` as mapped in `subParsers` for parsing instead of using `parser`.

Parsing errors are handled by a `private` `handleError` method and only the logs are printed to `stdout`.

Note that during execution of `parseCommand`, to initialize a `ModuleCommand` object, `Parser` will initialize an `Arguments` object from the parsed `Namespace` object to feed into the `ModuleCommand` object's constructor. However, `Arguments` is not a required class for `Parser` 's `parse` method to work.

===== Operation Explanation
Below is a step-by-step explanation of `Parser` 's operation principles:

Step 1. User launches the application. An instance of `Parser` will be initialized inside the `CliLauncher` class.

Step 2. User inputs a command to the command line, `PlannerUi` will capture the command and pass over to `Parser` 's `parse` method for interpretation.

Step 3. `Parser` receives the command, matches it against a suitable `ModuleCommand` class and parses all required arguments. If the command is invalid or missing any required arguments, `Parser` will print the errors to the command line using `PlannerUi` with corresponding helps and command suggestions. This process lies in the `handleError` method. If such errors happen, go back to Step 2.

Step 4. Upon successful command matching and arguments extracting, `Parser` initializes an instance of `Arguments` with a `Namespace` object containing parsed arguments as parameters and make a call to the Constructor of the corresponding `ModuleCommand` child class with the `Arguments` object as parameter.

Step 5. If the call succeeds, `Parser` will return the parsed `ModuleCommand` object. Any exceptions thrown during this call will be caught by `Parser` and either converted to a suitable `ModException` object or logged to the console.

A sequence diagram for `parseCommand` can be found below.

image::ParseCommandSequenceDiagram.png[]

The `ModuleCommand` class is not seen in the diagram because `Parser` might not call any `ModuleCommand`-type objects. The only guarantee is that an object with class that inherits from `ModuleCommand` will be returned.

==== Design consideration
* *Pros*: Robust and reliable, includes helps and commands suggestion, also very scalable.
* *Cons*: No easy way to format help messages.

As the `argparse4j` 's library itself is very robust and powerful, we currently have no plan to modify `Parser` 's implementation. However, addition of custom `Action` will be considered as currently only `Join` is being used for parsing of multiple words `String` arguments.

// end::Parser[]

***

=== Grading

==== Overview
Grading is a feature implemented to allow users to store their letter grades with the modules they have taken. The letter grades are parsed and its validity deemed according to the attributes of the modules they are storing it in. For example, if a module can be S/U-ed then the feature will allow user's to grade that module with a 'S' or 'U' grade.

==== Current Implementation
The `grade` feature is operated by the `GradeCommand` class, which is called by the `Parser` class. Upon user input of `grade MODULECODE LETTERGRADE`, the Parser will return a new `GradeCommand`.

Since `GradeCommand` inherits the `ModuleCommand` class, it must override the `execute` method to specially execute the `grade` command.
From the `Parser`, `GradeCommand` also receives two additional variable inputs from the user: +

. The module code of the module to be graded.
. The letter grade attained for the module that the user specifies above.

There are two ways that the execute method can execute, depending upon whether the moduleCode the user enters is in their moduleTaskList or not. In both cases the updated grade is stored along with the module details in the `Storage` package.

****

* Case 1: Module is not in the task list +
If the module is not in the task list, `GradeCommand` executes in a similar fashion to `SearchThenAddCommand`, creating a temporary `ModuleInfoDetailed` class to check if the moduleCode entered by the user exists or not. +
Following which, the letterGrade of the module is set using the method `setGrade` under the `ModuleInfoDetailed` class.
+
** *Note:* The `setGrade` method will check if the letterGrade input by the user is valid (a valid letter grade, as well as S/U capabilities).
+
If the letter grade is invalid, either `ModModBadSUException` or `ModBadGradeException` will be thrown.
+
Finally, the temporary module will be added to the `ModuleTaskList`, with the `letterGrade` included in its details.

* Case 2: Module is in the task list
If the module already exists in the task list, (i.e `ModuleTaskList` contains `moduleCode`) `GradeCommand` will simply check if the module can be S/U-ed, and update the `letterGrade` according to what the user inputs using the `setGrade` method.

****

Below is a Sequence Diagram showing how `GradeCommand` works.

image::GradeCommandSequenceDiagram.png[]

==== Design Considerations
*How GradeCommand executes*

Checks had to be implemented to check if the module can be S/U-ed, as well as if the `letterGrade` the user inputs is a valid grade according to NUS specifications.
These checks were implemented into the `ModuleInfoDetailed` class itself, which `ModuleTask` inherits as the baseline of the module task list. This way, other classes are able to use the methods and checks to set the letter grade for the respective module.

* Pros: This checking system can be used by other classes/methods just by calling the method under `ModuleInfoDetailed`.
* Cons: Calling the method requires a much deeper reach to extract the method/check needed, and may impact the code simplicity.

Other alternatives would be to have the checks directly in the `GradeCommand` class, however this alternative was disregarded as other `Command` that required use of these checks were created, such as the `CapCommand` class.

***

=== Cap Calculation
==== Overview
This feature allows users to calculate their Cumulative Average Point (NUS's version of GPA) from their inputted data. It uses various external data, as well as prerequisite and preclusion module checks to determine the user's CAP in three different ways. +

==== Current Implementation
The `cap` feature is operated by the `CapCommand` class, which is called by the `Parser` class. Upon user input of `cap TYPE`, the Parser will return a new `CapCommand`. +

Since `CapCommand` inherits the `ModuleCommand` class, it must override the `execute` method to specially execute the `cap` command. +

The parameter `TYPE` can take three forms according to the user input: +
****
* `cap overall` Where the user inputs modules of their choosing, as well as the letter grade, and the CAP is calculated accordingly.
* `cap list` Where the user's CAP is calculated from the modules with letter grades in the module task list.
* `cap module` Where the CAP of a module of the user's choosing can be calculated using the grades of prerequisite modules that the user has completed.
****

These `TYPE` parameters will be parsed by the `Parser` class and pass the corresponding argument of `toCap` into the `CapCommand` class. A switch case statement will handle the `toCap` argument, and choose to execute from three methods accordingly: +
`calculateOverallCap`,
`calculateListCap`
and
`calculateModuleCap` +

Upon construction of the `CapCommand` class, a few variables involved in calculating the CAP of the user are initialized, notably the users `mcCount`, `currentCap`, `projectedModuleCap` and `projectedCap`. These variables will be used in the three different ways CapCommand can currently execute in.

The user's CAP is calculated according to NUS guidelines, following the below specifications: +

image::CAPchart.png[align=""center""]

image::CAPformula.png[align=""center""]

As stated above, there are three methods that can be executed depending upon the `TYPE` the user inputs.

****
* Case 1: `cap overall` +
If the argument read for `toCap` is ""overall"", the `calculateOverallCap` method will be executed under the `execute` method. +
Firstly, a new `Scanner` will be created to continue reading in the modules and grades that the user wishes to calculate their CAP for. +
The user will be prompted to input a module and its respective letter grade. +
The user inputs are read in until the user inputs `done`, proceeding which the scanner will close and the calculation is done. +
Finally the user's CAP is calculated and printed.

* Case 2: `cap list` +
If the argument read for `toCap` is ""list"", the `calculateListCap` method will be executed under the `execute` method. +
This method calculates the CAP of modules from the user's `ModuleTaskList`.
** Note it will only take into account modules that have a letter grade attached to its details, and calculate the CAP accordingly. +

* Case 3: `cap module` +
If the argument read for `toCap` is ""module"", the `calculateModuleCap` method will be executed under the `execute` method. +
This method calculates the CAP of modules from the user's completed prerequisites in their `ModuleTaskList`. +
Firstly, a new `Scanner` will be created to continue reading in the module that the user wishes to calculate a predicted CAP for. +
After taking in the user input, ModPlan will check if the module is a legitimate module in the `detailedMap` pulled from NUSMODS API. +
If it is invalid, a new `ModNotFoundException` will be thrown. Otherwise the prerequisite tree (if any) will be scanned for that particular module using the `parsePrerequisiteTree` method. +

For the `cap module` command, we came up with two ways to go about parsing the prerequisite tree of the module whose CAP is to be predicted. 

*Alternative 1: Array of Module Codes* (currently implemented)
Currently in v1.4 the `cap module` method only parses the first level of prerequisites that a module has, as well as their preclusions, and checks against the user's module task list. 

If there are any prerequisite modules taken for the predicted module, their grades will be taken to predict the CAP for the inputted module. The array of module codes is rechecked again for any remaining preclusions that may have been omitted, before finally calculating and printing the CAP for the user.

*Alternative 2: List of List of Strings* (coming in v2.0)
This method uses the string split method to parse the string of prerequisites into individual module codes, and sorts them into a List of Lists of Strings (LLS). 

Each List of Strings (LS) contains prerequesite modules as part of an 'or' tree, while the modules across the LLS are part of an 'and' tree. Once the methods finds one of the prerequisite modules in a LS that corresponds to a graded module taken in the user's module task list, it removes that LS entirely from the LLS, and moves on to check the next LS for any prerequisite modules taken. 

If the entire LLS is empty at the end of the execution, it means that the user has fulfilled enough of the prerequisite modules required for that module, and the user's CAP is calculated according to the graded prerequisite modules identified in the user's module task list. +

The diagram below shows the example more clearly, where only one of the prerequisites within a LS need to be taken, while all of prerequisites across the LLS need to be taken. +

image::CapCommandLLS.png[align=""center""] 

In this case, the modules the user needs to take are: +

* One of moduleCode1, moduleCode2, moduleCode3 +
* moduleCode4 +
* moduleCode5 +
****

Below is a sequence diagram showing how `CapCommand` works. +

image::CapCommandSequenceDiagram.png[]

As seen `CapCommand` uses three different CAP calculation methods contained within itself to generate the CAP reports, in addition to all the sub-methods such as `letterGradeToCap` and `parsePrerequisiteTree`, and then pushes the information to `PlannerUi` for printing. 
It also instantiates different `Exception` classes to feedback to the user if anything is wrong.

=== Sorting

==== Current implementation

The `sort` feature is operated by the `SortCommand` class, which is called by the `Parser` class. Upon user input of `sort TOSORT TYPE`, the Parser will return a new `SortCommand`.

Since `SortCommand` inherits the `ModuleCommand` class, it must override the `execute` method to specially execute the `SortCommand`. From the `Parser`, `SortCommand` also receives two additional variable inputs from the user: +

****
* The object to sort, e.g. module, cca or time.
* The type of sorting the user specifies. e.g. for modules they can sort by code, grade, level and mcs; and for time they must specify a day of the week.
****


The parameter `TYPE` can take three main forms according to the user input:
****
* `sort cca` Where the user receives a sorted list of their ccas in alphabetical order. +
* `sort time DAY_OF_WEEK` Where the user receives a list of ccas and/or modules in a timely order for the day of week they choose. +
* `sort module BY` Where the user receives a sorted list of their modules in the order they specifies. +
****

These `TYPE` parameters will be parsed by the `Parser` class and pass the corresponding argument of `toSort` into the `SortCommand` class. A switch case statement will handle the `toSort` argument, and choose to execute the corresponding sorting. 

As stated above, there are three forms that can be executed depending upon the `TYPE` the user inputs.
****
* Case 1: `sort cca` +
If the argument read for `toSort` is “cca”, the cca list will be sorted in alphabetical order, and printed to the users. +
* Case 2: `sort time DAY_OF_WEEK` +
If the argument read for `toSort` is “time”, a new list of TaskWithMultipleWeeklyPeriod will be initialized, and all the ccas and modules that happens on the specified DAY_OF_WEEK will be added to the new list. This list is then sorted in ascending order of the starting time of the ccas/modules, and this list is printed to the users. +
** Note it will only take into account modules that was initially given a time period of the week attached to its details. +
* Case 3: `sort module BY` +
If the argument read for `toSort` is “module”, another switch case statement will handle the `BY` argument, and choose to execute the corresponding sorting of the modules. The options for `BY` are `code`, `grade`, `level` and `mc`. +
****

For all the above forms, the users may choose to enter an optional flag of `--r` to have all their modules/ccas sorted in the reverse order. This is done by the parser setting the argument as true (default is set as false). Then if the argument is true, the previously sorted list will be reversed then printed to the users. 

Below is a Sequence Diagram showing how `SortCommand` works.
SortCommand inherits the attributes and methods from the ModuleCommand, which is shown by the 1.1 arg arrow connecting SortCommand and ModuleCommand. The ModuleCommand calls itself as it uses its own attributes method as shown by 1.1.1 args. The SortCommand also calls certain methods of PlannerUi as shown by the arrows from 1.2 and 1.3 args. This is because the SortCommand uses the methods in PlannerUi such as the `sortMsg`, `showSorted` and `showSortedTimes`.

As both the modules and ccas inherit from the class `TaskWithMultipleWeeklyPeriod`, when the users indicate they want to `sort time DAY_OF_WEEK`, the SortCommand calls the `happensOnThisDayOfWeek` method to check whether the module or cca in the list happens on the `DAY_OF_WEEK` specified by the user, then adds to a temporary list. The method `getTimePeriodOfTheDay` from `TaskWithMultipleWeeklyPeriod` is used to sort the modules and ccas in a timely order.

image::SortCommandSequentialDiagram.png[width=""800""]

=== Showing Module Reports

==== Current implementation

The `show` feature is opearted by the `ShowCommand` class, which is called by the `Parser` class. Upon user input of `show TYPE`, the Parser will return a new `ShowCommand`. +

Since `ShowCommand` inherits the `ModuleCommand` class, it must override the `execute` method to specially execute the `show` command. +

The parameter `TYPE` can take five forms according to the user input: +

****
* `show cca`
* `show core`
* `show ge`
* `show ue`
* `show module`
****

These `TYPE` parameters will be parsed by the `Parser` class and pass the corresponding argument of `toShow` into the `ShowCommand` class. A switch case statement will handle the `toShow` argument.

Upon construction of the `ShowCommand` class, one variable involved in the generation of the report is initiazlised, which refers to the `coreModList`. This variable is being used to store the strings of core modules taken by CEG students throughout the four years. The list of core modules are being taken from the NUS module requirements website. +

As stated above, there are five methods that can be executed depending on the `TYPE` that the user inputs.

****
* Case 1: `show cca` +
If the argument read for `toShow` is ""cca"", an iterator iterates through the array list of `ccas`, which includes the CCAs added, and prints it out.

* Case 2: `show core` +
If the argument read for `toShow` is ""core"", an iterator loops through the array list of `ModuleTask` and checks it against the set of `coreModList`. If the `moduleCode` in `ModuleTask` matches the `moduleCode` from the `coreModList`, that `moduleCode` is being printed out. 

** The second part subtracts the number of core modules taken from the total number of core modules required to be taken, which the information is taken from the NUS module requirements website. Hence, it shows the users the number of core modules left to take for the rest of the years.

* Case 3: `show ge` +
If the argument read for `toShow` is ""ge"", an iterator loops through the array list of `ModuleTask` and checks the starting two letters of the `moduleCode`. If the `moduleCode` starts with a ""GE"", it is classified as a General Elective(GE) module and will be printed out.

** The second part subtracts the number of GE modules taken from the total number of GE modules required to be taken, which the information is taken from the NUS module requirements website. Hence, it shows the users the number of GE modules left to take for the rest of the years.

* Case 4: `show ue` +
If the argument read for `toShow` is ""ue"", an iterator loops through the array list of `ModuleTask`. It checks the starting two letters of the `moduleCode` and also checks the `moduleCode` against the set of `coreModList`. If the `moduleCode`  does not match the `moduleCode` from the `coreModList` and it does not start with a `GE`, it is classified as a Unrestricted Elective(UE) module and will be printed out.

** The second part subtracts the number of UE modules taken from the total number of UE modules required to be taken, which the information is taken from the NUS module requirements website. Hence, it shows the users the number of UE modules left to take for the rest of the years.

* Case 5: `show module` +
If the argument read for `toShow` is ""module"", an iterator loops through the array list of `ModuleTask`. It then prints out the entire list of modules being added.

Below is a Sequence Diagram showing how `ShowCommand` works. +
ShowCommand inherits the attributes and methods from the ModuleCommand, which is shown by the 1.1 arg arrow connecting ShowCommand and ModuleCommand. The ModuleCommand calls itself as it uses its own attributes method as shown by 1.1.1 arg. The ShowCommand also calls certain methods of PlannerUi as shown by the arrows from 1.2 to 1.11 args. This is because the ShowCommand uses the methods in PlannerUi such as the `listCcaMsg` and `coreModReport`.

image::ShowCommandSequenceDiagram.png[width=""600""]

****

=== Update Reminders

==== Current implementation

The `reminder` feature is operated by the `ReminderCommand` class, which is called by the `Parser` class. Upon user input of `reminder TYPE`, the Parser will return a new `ReminderCommand`. +

Since `ReminderCommand` inherits the `ModuleCommand` class, it must override the `execute` method to specially execute the `reminder` command. +

The parameter `NUMBER` can take six forms according to the user input: +

****
* `reminder list`
* `reminder one`
* `reminder two`
* `reminder three`
* `reminder four`
* `reminder stop`
****

These `TYPE` parameters will be parsed by the `Parser` class and pass the corresponding argument of `toReminder` into the `ReminderCommand` class. A switch case statement will handle the `toReminder` argument.

Upon construction of the `ReminderCommand` class, variables using Timer class and ScheduledTask class are inititalised.

As stated above, there are six methods that can be executed depending on the `TYPE` that the user inputs.

****
* Case 1: `reminder list` + 
If the argument read for `toReminder` is ""list"", the reminderList() method in plannerUI class is called. A list of the different reminder interval options are being printed. The four different options allow user to determine how often the user want to set the update reminder message. User can set the reminder message to pop up every 10 seconds, 30 seconds, 1 minute or 2 minutes.

* Case 2: `reminder one` + 
If the argument read for `toReminder` is ""one"", the printEveryTenSec() method is called. The `time` variable initialised by the Timer class is used to schedule the reminder message in ScheduledTask class every 10000ms, which equates to 10 seconds.

* Case 3: `reminder two` + 
If the argument read for `toReminder` is ""two"", the printEveryThirtySec() method is called. The `time` variable initialised by the Timer class is used to schedule the reminder message in ScheduledTask class every 30000ms, which equates to 30 seconds.

* Case 4: `reminder three` + 
If the argument read for `toReminder` is ""three"", the printEveryOneMin() method is called. The `time` variable initialised by the Timer class is used to schedule the reminder message in ScheduledTask class every 60000ms, which equates to 1 minute.

* Case 5: `reminder four` + 
If the argument read for `toReminder` is ""four"", the printEveryTwoMin() method is called. The `time` variable initialised by the Timer class is used to schedule the reminder message in ScheduledTask class every 120000ms, which equates to 2 minutes.

* Case 6: `reminder stop` + 
If the argument read for `toReminder` is ""stop"", the killAllTimers() method is called. A Timer iterator loops through the list of all the Timer threads and cancels all the Timer tasks. A message is then printed to notify the user that the reminder message for the update is being stopped.

Below is a Sequence Diagram showing how `ReminderCommand` works. +
ReminderCommand inherits the attributes and methods from the ModuleCommand, which is shown by the 1.1 arg arrow connecting ReminderCommand and ModuleCommand. The ModuleCommand calls itself as it uses its own attributes method as shown by 1.1.1 arg. The ReminderCommand also calls the reminderList method in PlannerUi as shown by the 1.2 arrow. The reminderList method, in turn calls itself by using the showLine method as shown by 1.2.1 arrow. The ReminderCommand calls its own method, such as printEveryTenSec as shown by the 1.3 arrow. It then uses an object in ModTimer class, which is removed from the memory, as shown by the 1.3.1 arrow. This repeats three more times as shown by the 1.4 to 1.6 arrows. Lastly, the ReminderCommand calls itself by using the killAllTimers method as shown by the 1.7 arrow.

image::ReminderCommandSequenceDiagram.png[width=""600""]

****


=== UpdateModuleCommand

==== Current implementation

The `update` feature is executed by the `UpdateModuleCommand` class, which is called by the `Parser` class. Upon user input of `update module`, the Parser will return a new `UpdateModuleCommand`. +


Since `UpdateModuleCommand` inherits the `ModuleCommand` class, it must override the `execute` method to specially execute the `update` command. +

Below is a Sequence Diagram showing how `UpdateModuleInfo` works. +
UpdateModuleCommand inherits the attributes and methods from the ModuleCommand, which is shown by the 1.1 arg arrow connecting the UpdateModuleCommand and ModuleCommand. The ModuleCommand calls itself as it uses its own attributes method as shown by 1.1.1 arg.
It then uses an object in NattyWrapper class, which is removed from the memory, as shown by the 1.3.1 arrow. The UpdateModuleCommand also calls the dateToLocalDateTime method from the NattyWrapper as shown by the 1.3 and 1.4 arrows. The UpdateModuleCommand fetches the updated module information from the RequestData , Storage and PlannerLogger, as shown by the 1.5 arrows. To end off, the UpdateModuleCommand calls the showUpdateMsg method from the PlannerUi to print the updated message.


image::UpdateModuleCommandSequenceDiagram.png[width=""800""]

=== JsonWrapper

==== Current implementation

`JsonWrapper` contains our usage of the `Gson` library for JSON file processing, as well as to call `RequestData` to obtained the module data consolidated by `NUSMODS API`.

image::PackageCrawler.png[]

To prevent multiple requests to NUSMODS, our implementation would check if the user has previously downloaded the module data before. If they have not, only then would `JsonWrapper` call `RequestData` to initialize the module data file.

The sequence diagram of this implementation is shown below:

image::JsonWrapperSequenceDiag.png[]

The above function is done in the `CliLauncher` class, during the setup function call.

Since `Gson` is able to internally read a JSON file and when given the same template within a Java object class, it would be able to map the value fields to each of the same keys in the Java Object.

This allows the application to have a direct access to all the modules which are currently offered in NUS, by reading the returned JSON string and parsing it directly into a list of Module information. Since the data had to be modelled, the
following ModuleInfoDetailed and ModuleInfoSummary was created to capture the data in the JSON file to be used during runtime.

image::PackageModule.png[]

Since some modules may not contain data for every field, each of the module classes above are required to have default values on initialisation so as to prevent `NullPointerExceptions` during runtime when such module data is accessed.

image::ModuleInfoDetailed.png[]

This also extends to choosing the right data type for modelling our module information, since certain fields maybe malformed and thus our implementation of the fields data type in module information classes would mostly contain `strings`, unless it is certain that
the data type found in the returned JSON string is strictly `boolean` or `double`.

To allow for quick access to the module information classes, after parsing module information into a list of `ModuleInfoDetailed`, it would then be converted into a `HashMap`, where the key-value pair
is the string containing the module code, and the value is the `ModuleInfoDetailed`.

This is `HashMap` is exposed to all the command classes during runtime, and this is done automatically on startup so that the module
data is accessible directly to the user. This functionality is handled by `JsonWrapper` since it involves parsing JSON files into direct Java Objects.

==== RequestData

Internally, this class is responsible for requesting data from the `NUSMODS API` and thus uses Java's Native `HTTPRequest` Library.

image::FutureRequests.png[]

The current implementation is fixed to only request data for the current academic year, but this is subject to change in the coming versions to allow for users to choose to update the data once it gets outdated.

A better implementation might be considered so that the class itself can be more customized for `ModPlan`.
=======
The remove further dependency on the Internet for making API calls to NUSMODS, in future this implementation would be modified to use provided the data in the JAR resources.

For the proposed implementation of updating user data, there are a few alternatives which could be considered:

****
* Alternative 1: There would be a prompt for the user on startup to check if they wish to update their module data. If the user decides to do so, they enter `yes` and it would be updated.
** Since this may be distracting for users on every startup, once they user entered `no`, it would no longer prompt for the data update.
** This implementation requires our application to remember user settings preferences which can be added as an additional feature.

* Alternative 2: Automatic prompting, where the initial startup date is recorded, and would be mapped to a particular semester.
** Once the semester has been completed, it would prompt the user to update the data. Since this requires and internet connection, this prompt is necessary.

* Alternative 3 (Selected): The base data is packaged into the resources package, thus the `JAR` would be able to generate the HashMap of ModuleInfoDetailed directly without needed to query from NUSMODS API.
** The existing implementation to connect to NUSMODS to obtain the module data would be converted to an Update command, giving the user flexibility to choose when to update their module data.
** After the user ran their first update command, it ModPlan will no longer read module data from the internal resource file,
but will read the data downloaded locally by the `update module` command.
****
=======

=== Logger

The follow dependency diagram shows the relationship Logger has with the rest of the other classes.

image::Logger.png[]

`LoggerFormatter` formats the logging standard which all logging entries uses. `PlannerLogger` is called on every exception handling errors which occurs in `Parser`, `JsonWrapper` and the main `CliLauncher` class.

It is present to capture all `ModException` errors as `WARNING`, while any other unhandled exceptions would be deemed as `SEVERE`.

The logging data is written to the `logging.log` file found in the data folder when the application is started.


// tag::Cca[]

=== Cca

`Cca` is a class designed for managing user-defined CCAs. All instances of `Cca` are stored in a `List`-like structure `TaskList<Cca>` which inherits from `ArrayList<TaskWithMultipleWeeklyPeriod>`.

==== Current implementation

These diagrams illustrate the `Cca` class:

image::CcaClassDiagram1.png[]
image::CcaClassDiagram2.png[]

`Cca` is a child class of the legacy class `TaskWithMultipleWeeklyPeriod` which belongs to our implementation of `Duke`. However, since `TaskWithMultipleWeeklyPeriod` is a legacy class, we will update on its implementation after setting up other features and documentations (preferably after ModPlan v2.0 release).

// end::Cca[]

== Coming in v2.0

=== Password management

==== Add or update an existing password: `passwd`
Add or update an existing password. +
If a password has been previously set (updating password mode), a prompt will show up asking for old password before a new one can setup. In that case, kindly enter your current password as prompted to setup a new one. +
Format: +
`passwd myPassword`

==== Implementation
Password management will be implemented in a new `SetPasswordCommand` class for password adding/updating in complementary with `ClearCommand` for password removing.

=== GUI
ModPlan v2.0 will support GUI (Graphical User Interface). We have not decided whether the CLI (Command Line Interface) will be fully replaced by GUI or will be an additional feature. However, the new GUI will hopefully improve ModPlan's user-friendliness and user's productivity.


[[Documentation]]

== Documentation
We utilise AsciiDoc as the default tool to write our documentation, as the layout is more flexible and aesthetically pleasing to view compared to other alternatives such as MarkDown. Additionally our preferred IDE IntelliJ has AsciiDoc support, and is thus easier for us to code and preview changes in.

We also use link:http://plantuml.com/[PlantUML] and link:https://www.draw.io/[draw.io] to help use make our diagrams used in this Developer's Guide. These software enable us to create different types of diagrams easily, and for free.

[[Testing]]

== Testing
=== Overview
We used JUnit to code our test cases, and Jacoco to monitor the test coverage of our project. 

There are two ways to run tests.

*Method 1: Using IntelliJ JUnit test runner*

* To run all tests, right-click on the `src/test/java` folder and choose `Run 'All Tests'`
* To run a subset of tests, you can right-click on a test package, test class, or a test and choose `Run 'specificTest'`

*Method 2: Using Gradle*

* Open a console and run the command `gradlew clean test` (Mac/Linux: `./gradlew clean test`)

=== Creating Tests
Create new test classes under the `/main/src/test/java/planner` package to increase the coverage of the tests for the project. 

* We have a sample testing framework put in place such as `CommandTest` to aid in testing implementation.
* Remember to utilise the JUnit assertions in your testing, as well as ensure testing works before pushing the repo.

[[DevOps]] 
== Dev Ops
=== Build Automation
We use https://gradle.org/[Gradle] to automate our build process, as well as to create our `JAR` release.

=== Continuous Integration
We use https://travis-ci.org/[Travis CI] to perform continuous integration on our project through GitHub. 

=== Code Coverage Reporting
We use https://www.eclemma.org/jacoco/[Jacoco] to check the code coverage of our project.

=== Making a Release

Here are the steps to create a new release.

*  Update the version number in link:{repoURL}/src/main/java/planner/main[`ModPlan.java`].
*  Generate a JAR file using gradle.
*  Tag the repo with the version number. e.g. `v0.1`
*  https://help.github.com/articles/creating-releases/[Create a new release using GitHub] and upload the JAR file you created.
//[[Legacy]]
//== Legacy Classes

//(TBD)

== Manual User Testing

The following should be obtained after running `show module`:

image::SampleShowModule.PNG[]

The following should be obtained after running `show cca`:

image::SampleShowCCA.PNG[]

Testing the `update module` command would work only if there is stable internet connection and that the NUSMODS Server API
is operational.


[appendix]
== Product Scope

*A better module planner*

We aim to fulfill a need that is currently lacking in module planning, which in this case the is ability to plan ahead for more semesters up until graduation. Additional features would likely include the ability to generate a projection report for CAP computation and CCA planning.

*Target Users*: NUS CEG Students +
* have a need for additional module planning aside from utilising NUSMODS. +
* comfortable with using CLI +
* can type fast +
* prefers desktop applications +
* has a computer with Internet access available +

*Value proposition*: +
* Provides many more features that NUSMODS currently does not have, which we have deemed to still be important to target users. +

[appendix]
== User Stories
Priorities: High (must have) - `* * \\*`, Medium (nice to have) - `* \\*`, Low (unlikely to have) - `*`

[width=""59%"",cols=""22%,<23%,<25%,<30%"",options=""header"",]
|=======================================================================
|Priority |As a ... |I can ... |So that ...
|`* * *` |NUS CEG Student |Search for a module's workload |Balance my workload for the current semester
|`* * *` |NUS CEG Student |Monitor my total workload from my modules |Track my total workload for the current semester 
|`* * *` |NUS Student |See my daily timetable |Keep a schedule of what classes and extra-curricular activities I have 
|`* * *` |NUS CEG Student |Check if I have completed the required prerequisite modules |Plan ahead for what modules to take 
|`* * *` |Forgetful NUS CEG Student |Add up my total number of MCs taken |Track my progress towards graduation 
|`* * *` |NUS CEG Student |View the core modules required for graduation |Know what are the modules I still need to take to graduate 
|`* *` |NUS Student |Add CCAs to my class timetable |Take CCAs that do not clash with my lessons 
|`* *` |NUS Student |Create a custom module for my CCAs |Personalise the timing and location of my CCA in my timetable 
|`* *` |NUS Undergraduate Student |Know requirements for a Master's/PHD at NUS |Plan my course of action if I wish to apply for post-graduate studies 
|`* *` |NUS CEG Student |Easy access to my recommended study schedule |Know what modules I should prioritise bidding for 
|`* *` |NUS CEG Student |Plan to take modules ahead of the current semester |Alter my holiday/graduation plans as required 
|`* *` |NUS CEG Student |Know what GE modules I have not completed |Plan to take GE modules over a few semesters 
|`* *` |NUS CEG Student |Know what UE modules I have completed |Plan to take UE modules over a few semesters
|`* *` |NUS CEG Student |View the total number of Level-1000 modules taken |Check if I have exceeded the 60MC limit for Level-1000 modules
|`* *` |NUS CEG Student |Know if the module has S/U options |Plan ahead for my S/U usage 
|`* *` |NUS CEG Student |Project my future CAP based on my expected and past grades |See how hard I must work to hit my target CAP 
|`*` |NUS CEG Student |Download my timetable as a photo |View it on other mediums such as my mobile phone 
|`*` |NUS Student |Know the directions to my classes |Plan my route accordingly 
|`*` |NUS Student |Know my priority score when bidding for a module |Plan my module bidding appropriately 
|`*` |NUS Student |See a list of my course's modules available in SEP/NOC |Plan what modules to take should I go for SEP/NOC 
|`*` |Exchange Student |Know if a module can be mapped to my home university |Plan what modules to take in NUS 

|=======================================================================
(more to be added as necessary)

[appendix]
== Use Cases

=== Use Case C01: Adding modules to user's timetable
Actor: NUS CEG Student

*MSS*

1. User inputs the module code
2. ModPlan shows the module information to the user, such as description, number of MCs, prerequisite modules etc. and requests confirmation from the user to add this module
3. User confirms they want to add the module 
4. ModPlan shows the non-clashing available timings of the module to the user
5. User confirms which class timing they wish to add to their timetable
6. ModPlan adds that specific class to the user's timetable, and prints the user's updated timetable +
Use case ends.

*Extensions*

2a1. If the module is a Level-1000 module, ModPlan checks for the user's current number of Level-1000 modules taken +
2a2. If the limit is not exceeded, proceed to step 3 +
2a3. If the limit will be exceeded, warn the user, and prevent addition of the module +
2a4. Additionally, if the prerequisites of the module have not been fulfilled, prevent addition of the module, and inform user of the modules needed to be taken +
Return to step 3.

=== Use Case C02: Viewing graduation requirements
Actor: NUS CEG Undergraduate Student

*MSS*

1. User inputs their course name
2. ModPlan shows the courses that match the user's input
3. User selects the correct course they wish to check graduation requirements for
4. ModPlan displays all the modules required for graduation, and lists the number of MCs required for graduation +
Use case ends.

*Extensions*

3a. User can input the modules they have taken already that count towards graduating that course
3b. ModPlan will exclude these modules from the list and MC count +
Return to Step 4.

=== Use Case C03: Viewing class and CCA timetable
Actor: NUS Student

*MSS*

1. User inputs the command to view timetable
2. ModPlan shows the user their current timetable, including class and CCA timings

=== Use Case C04: Viewing of modules taken in past semester
Actor: NUS Student

*MSS*

1. User inputs the command to view past modules
2. ModPlan shows the user a list of all modules taken, and those they are currently taking. +
Use case ends.

=== Use Case C05: Generation of current CAP based on past modules
Actor: NUS Student

*MSS*

1. User inputs the command to generate CAP report
2. ModPlan shows the user modules they had taken, and requests user to input their grades obtained
3. User inputs the modules they have taken, as well as the respective grades obtained
4. After inputting the grades, ModPlan calculates and shows the user their current MCs accumulated and CAP. +
Use case ends.

*Extensions*

4a. User can then input a future module they plan to take and project their CAP
4b. ModPlan will show the projected CAP using grades the user obtained from the module's prerequisite classes

=== Use Case C06: Check Module information via input search
Actor: NUS Student

*MSS*

1. User inputs the command to search module information
2. ModPlan shows the user key information regarding the module, if it is SU-able or if it has any prequisites. +
Use case ends.

=== Use Case C07: Creating a personalised Module (eg. for CCAs)
Actor: NUS Student

*MSS*

1. User inputs the command to create custom module
2. ModPlan prompts the user for additional details of the custom module, such as description and times
3. User inputs the description and date/times
4. ModPlan prompts user to confirm addition of custom module to timetable
5. User confirms addition
6. ModPlan adds custom module to timetable, and shows user updated timetable. +
Use case ends.

*Extensions*

5a. User can cancel addition + 
5b. ModPlan will cancel addition of custom module, and delete information inputted

=== Use Case C08: Checking number of MCs taken
Actor: NUS Student

*MSS*

1. User inputs the command to check MC
2. ModPlan will show the total MCs taken up to this point. +
Use case ends.

*Extensions*

1a. User can specify additional parameters to check MCs completed for specific periods +
eg. `check MC 1-1` will check for MCs taken in Year 1 Semester 1

(Use case will be tackled in v2.0 with multiple semester support)

[appendix]
== Non-Functional Requirements

1. ModPlan should run on any machine with JDK `11` and above installed. 
2. ModPlan should be fast to view and input commands.
3. ModPlan should require as few steps as possible for the user to do what they want to do.
4. ModPlan should store data between sessions so the user does not have to input all their information again.
5. ModPlan should scrape data from NUSMODS API at least once a semester to keep up to date with any changes in modules.

[appendix]
== Manual User Testing

We have included a base data file populated with ~20 modules and ~5 CCAs for manual testing. The program will load from these data files upon the first startup if a save file is not found. 

=== Loading Manual Test Data
==== Test Data

To demonstrate the functionality of the product, the `JAR` release contains sample data so that the user can easily test
and observe that the application runs as intended.

Type `show module` and observe that the following output is obtained:

image::ShowModuleTest.png[]

The following should be obtained after running `show cca`:

image::ShowCcaTest.png[]

Testing the `update module` command would work only if there is stable internet connection and that the NUSMODS Server API
is operational.

=== Manual Testing

To test our product manually, kindly open the `[CS2113T-F10-1][ModPlan].jar` file from the `v1.4` release using the command prompt of your preferred OS, and test using commands featured in our https://github.com/AY1920S1-CS2113T-F10-1/main/blob/master/docs/UserGuide.adoc[User Guide].

[appendix]
== Glossary

* *API* : Application Programming Interface
* *CEG* : Computer Engineering
* *NUSMODS* : NUSMODS is an external library where consolidated module data from NUS is collected
* *JSON* : JavaScript Object Notation
",12278,False,2082.2388824593313,median
"/*************************************************************************/
/*  baked_lightmap.cpp                                                   */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                      https://godotengine.org                          */
/*************************************************************************/
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
/*                                                                       */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the       */
/* ""Software""), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/

#include ""baked_lightmap.h""
#include ""core/io/config_file.h""
#include ""core/io/resource_saver.h""
#include ""core/math/math_defs.h""
#include ""core/os/dir_access.h""
#include ""core/os/os.h""
#include ""voxel_light_baker.h""

void BakedLightmapData::set_bounds(const AABB &p_bounds) {
	bounds = p_bounds;
	VS::get_singleton()->lightmap_capture_set_bounds(baked_light, p_bounds);
}

AABB BakedLightmapData::get_bounds() const {
	return bounds;
}

void BakedLightmapData::set_octree(const PoolVector<uint8_t> &p_octree) {
	VS::get_singleton()->lightmap_capture_set_octree(baked_light, p_octree);
}

PoolVector<uint8_t> BakedLightmapData::get_octree() const {
	return VS::get_singleton()->lightmap_capture_get_octree(baked_light);
}

void BakedLightmapData::set_cell_space_transform(const Transform &p_xform) {
	cell_space_xform = p_xform;
	VS::get_singleton()->lightmap_capture_set_octree_cell_transform(baked_light, p_xform);
}

Transform BakedLightmapData::get_cell_space_transform() const {
	return cell_space_xform;
}

void BakedLightmapData::set_cell_subdiv(int p_cell_subdiv) {
	cell_subdiv = p_cell_subdiv;
	VS::get_singleton()->lightmap_capture_set_octree_cell_subdiv(baked_light, p_cell_subdiv);
}

int BakedLightmapData::get_cell_subdiv() const {
	return cell_subdiv;
}

void BakedLightmapData::set_energy(float p_energy) {
	energy = p_energy;
	VS::get_singleton()->lightmap_capture_set_energy(baked_light, energy);
}

float BakedLightmapData::get_energy() const {
	return energy;
}

void BakedLightmapData::set_interior(bool p_interior) {
	interior = p_interior;
	VS::get_singleton()->lightmap_capture_set_interior(baked_light, interior);
}

bool BakedLightmapData::is_interior() const {
	return interior;
}

void BakedLightmapData::add_user(const NodePath &p_path, const Ref<Resource> &p_lightmap, int p_lightmap_slice, const Rect2 &p_lightmap_uv_rect, int p_instance) {
	ERR_FAIL_COND_MSG(p_lightmap.is_null(), ""It's not a reference to a valid Texture object."");
	ERR_FAIL_COND(p_lightmap_slice == -1 && !Object::cast_to<Texture>(p_lightmap.ptr()));
	ERR_FAIL_COND(p_lightmap_slice != -1 && !Object::cast_to<TextureLayered>(p_lightmap.ptr()));

	User user;
	user.path = p_path;
	if (p_lightmap_slice == -1) {
		user.lightmap.single = p_lightmap;
	} else {
		user.lightmap.layered = p_lightmap;
	}
	user.lightmap_slice = p_lightmap_slice;
	user.lightmap_uv_rect = p_lightmap_uv_rect;
	user.instance_index = p_instance;
	users.push_back(user);
}

int BakedLightmapData::get_user_count() const {
	return users.size();
}
NodePath BakedLightmapData::get_user_path(int p_user) const {
	ERR_FAIL_INDEX_V(p_user, users.size(), NodePath());
	return users[p_user].path;
}
Ref<Resource> BakedLightmapData::get_user_lightmap(int p_user) const {
	ERR_FAIL_INDEX_V(p_user, users.size(), Ref<Resource>());
	if (users[p_user].lightmap_slice == -1) {
		return users[p_user].lightmap.single;
	} else {
		return users[p_user].lightmap.layered;
	}
}

int BakedLightmapData::get_user_lightmap_slice(int p_user) const {
	ERR_FAIL_INDEX_V(p_user, users.size(), -1);
	return users[p_user].lightmap_slice;
}

Rect2 BakedLightmapData::get_user_lightmap_uv_rect(int p_user) const {
	ERR_FAIL_INDEX_V(p_user, users.size(), Rect2(0, 0, 1, 1));
	return users[p_user].lightmap_uv_rect;
}

int BakedLightmapData::get_user_instance(int p_user) const {
	ERR_FAIL_INDEX_V(p_user, users.size(), -1);
	return users[p_user].instance_index;
}

void BakedLightmapData::clear_users() {
	users.clear();
}

void BakedLightmapData::clear_data() {
	clear_users();
	if (baked_light.is_valid()) {
		VS::get_singleton()->free(baked_light);
	}
	baked_light = RID_PRIME(VS::get_singleton()->lightmap_capture_create());
}

void BakedLightmapData::_set_user_data(const Array &p_data) {
	ERR_FAIL_COND(p_data.size() <= 0);

	// Detect old lightmapper format
	if (p_data.size() % 3 == 0) {
		bool is_old_format = true;
		for (int i = 0; i < p_data.size(); i += 3) {
			is_old_format = is_old_format && p_data[i + 0].get_type() == Variant::NODE_PATH;
			is_old_format = is_old_format && p_data[i + 1].is_ref();
			is_old_format = is_old_format && p_data[i + 2].get_type() == Variant::INT;
			if (!is_old_format) {
				break;
			}
		}
		if (is_old_format) {
#ifdef DEBUG_ENABLED
			WARN_PRINT(""Geometry at path "" + String(p_data[0]) + "" is using old lightmapper data. Please re-bake."");
#endif
			Array adapted_data;
			adapted_data.resize((p_data.size() / 3) * 5);
			for (int i = 0; i < p_data.size() / 3; i++) {
				adapted_data[i * 5 + 0] = p_data[i * 3 + 0];
				adapted_data[i * 5 + 1] = p_data[i * 3 + 1];
				adapted_data[i * 5 + 2] = -1;
				adapted_data[i * 5 + 3] = Rect2(0, 0, 1, 1);
				adapted_data[i * 5 + 4] = p_data[i * 3 + 2];
			}
			_set_user_data(adapted_data);
			return;
		}
	}

	ERR_FAIL_COND((p_data.size() % 5) != 0);

	for (int i = 0; i < p_data.size(); i += 5) {
		add_user(p_data[i], p_data[i + 1], p_data[i + 2], p_data[i + 3], p_data[i + 4]);
	}
}

Array BakedLightmapData::_get_user_data() const {
	Array ret;
	for (int i = 0; i < users.size(); i++) {
		ret.push_back(users[i].path);
		ret.push_back(users[i].lightmap_slice == -1 ? Ref<Resource>(users[i].lightmap.single) : Ref<Resource>(users[i].lightmap.layered));
		ret.push_back(users[i].lightmap_slice);
		ret.push_back(users[i].lightmap_uv_rect);
		ret.push_back(users[i].instance_index);
	}
	return ret;
}

RID BakedLightmapData::get_rid() const {
	return baked_light;
}
void BakedLightmapData::_bind_methods() {
	ClassDB::bind_method(D_METHOD(""_set_user_data"", ""data""), &BakedLightmapData::_set_user_data);
	ClassDB::bind_method(D_METHOD(""_get_user_data""), &BakedLightmapData::_get_user_data);

	ClassDB::bind_method(D_METHOD(""set_bounds"", ""bounds""), &BakedLightmapData::set_bounds);
	ClassDB::bind_method(D_METHOD(""get_bounds""), &BakedLightmapData::get_bounds);

	ClassDB::bind_method(D_METHOD(""set_cell_space_transform"", ""xform""), &BakedLightmapData::set_cell_space_transform);
	ClassDB::bind_method(D_METHOD(""get_cell_space_transform""), &BakedLightmapData::get_cell_space_transform);

	ClassDB::bind_method(D_METHOD(""set_cell_subdiv"", ""cell_subdiv""), &BakedLightmapData::set_cell_subdiv);
	ClassDB::bind_method(D_METHOD(""get_cell_subdiv""), &BakedLightmapData::get_cell_subdiv);

	ClassDB::bind_method(D_METHOD(""set_octree"", ""octree""), &BakedLightmapData::set_octree);
	ClassDB::bind_method(D_METHOD(""get_octree""), &BakedLightmapData::get_octree);

	ClassDB::bind_method(D_METHOD(""set_energy"", ""energy""), &BakedLightmapData::set_energy);
	ClassDB::bind_method(D_METHOD(""get_energy""), &BakedLightmapData::get_energy);

	ClassDB::bind_method(D_METHOD(""set_interior"", ""interior""), &BakedLightmapData::set_interior);
	ClassDB::bind_method(D_METHOD(""is_interior""), &BakedLightmapData::is_interior);

	ClassDB::bind_method(D_METHOD(""add_user"", ""path"", ""lightmap"", ""lightmap_slice"", ""lightmap_uv_rect"", ""instance""), &BakedLightmapData::add_user);
	ClassDB::bind_method(D_METHOD(""get_user_count""), &BakedLightmapData::get_user_count);
	ClassDB::bind_method(D_METHOD(""get_user_path"", ""user_idx""), &BakedLightmapData::get_user_path);
	ClassDB::bind_method(D_METHOD(""get_user_lightmap"", ""user_idx""), &BakedLightmapData::get_user_lightmap);
	ClassDB::bind_method(D_METHOD(""clear_users""), &BakedLightmapData::clear_users);
	ClassDB::bind_method(D_METHOD(""clear_data""), &BakedLightmapData::clear_data);

	ADD_PROPERTY(PropertyInfo(Variant::AABB, ""bounds"", PROPERTY_HINT_NONE, """", PROPERTY_USAGE_NOEDITOR), ""set_bounds"", ""get_bounds"");
	ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM, ""cell_space_transform"", PROPERTY_HINT_NONE, """", PROPERTY_USAGE_NOEDITOR), ""set_cell_space_transform"", ""get_cell_space_transform"");
	ADD_PROPERTY(PropertyInfo(Variant::INT, ""cell_subdiv"", PROPERTY_HINT_NONE, """", PROPERTY_USAGE_NOEDITOR), ""set_cell_subdiv"", ""get_cell_subdiv"");
	ADD_PROPERTY(PropertyInfo(Variant::REAL, ""energy"", PROPERTY_HINT_RANGE, ""0,16,0.01,or_greater""), ""set_energy"", ""get_energy"");
	ADD_PROPERTY(PropertyInfo(Variant::BOOL, ""interior""), ""set_interior"", ""is_interior"");
	ADD_PROPERTY(PropertyInfo(Variant::POOL_BYTE_ARRAY, ""octree"", PROPERTY_HINT_NONE, """", PROPERTY_USAGE_NOEDITOR), ""set_octree"", ""get_octree"");
	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, ""user_data"", PROPERTY_HINT_NONE, """", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL), ""_set_user_data"", ""_get_user_data"");
}

BakedLightmapData::BakedLightmapData() {
	baked_light = RID_PRIME(VS::get_singleton()->lightmap_capture_create());
	energy = 1;
	cell_subdiv = 1;
	interior = false;
}

BakedLightmapData::~BakedLightmapData() {
	VS::get_singleton()->free(baked_light);
}

///////////////////////////

Lightmapper::BakeStepFunc BakedLightmap::bake_step_function;
Lightmapper::BakeStepFunc BakedLightmap::bake_substep_function;
Lightmapper::BakeEndFunc BakedLightmap::bake_end_function;

Size2i BakedLightmap::_compute_lightmap_size(const MeshesFound &p_mesh) {
	double area = 0;
	double uv_area = 0;
	for (int i = 0; i < p_mesh.mesh->get_surface_count(); i++) {
		Array arrays = p_mesh.mesh->surface_get_arrays(i);
		PoolVector<Vector3> vertices = arrays[Mesh::ARRAY_VERTEX];
		PoolVector<Vector2> uv2 = arrays[Mesh::ARRAY_TEX_UV2];
		PoolVector<int> indices = arrays[Mesh::ARRAY_INDEX];

		ERR_FAIL_COND_V(vertices.size() == 0, Vector2());
		ERR_FAIL_COND_V(uv2.size() == 0, Vector2());

		int vc = vertices.size();
		PoolVector<Vector3>::Read vr = vertices.read();
		PoolVector<Vector2>::Read u2r = uv2.read();
		PoolVector<int>::Read ir;
		int ic = 0;

		if (indices.size()) {
			ic = indices.size();
			ir = indices.read();
		}

		int faces = ic ? ic / 3 : vc / 3;
		for (int j = 0; j < faces; j++) {
			Vector3 vertex[3];
			Vector2 uv[3];

			for (int k = 0; k < 3; k++) {
				int idx = ic ? ir[j * 3 + k] : j * 3 + k;
				vertex[k] = p_mesh.xform.xform(vr[idx]);
				uv[k] = u2r[idx];
			}

			Vector3 p1 = vertex[0];
			Vector3 p2 = vertex[1];
			Vector3 p3 = vertex[2];
			double a = p1.distance_to(p2);
			double b = p2.distance_to(p3);
			double c = p3.distance_to(p1);
			double halfPerimeter = (a + b + c) / 2.0;
			area += sqrt(halfPerimeter * (halfPerimeter - a) * (halfPerimeter - b) * (halfPerimeter - c));

			Vector2 uv_p1 = uv[0];
			Vector2 uv_p2 = uv[1];
			Vector2 uv_p3 = uv[2];
			double uv_a = uv_p1.distance_to(uv_p2);
			double uv_b = uv_p2.distance_to(uv_p3);
			double uv_c = uv_p3.distance_to(uv_p1);
			double uv_halfPerimeter = (uv_a + uv_b + uv_c) / 2.0;
			uv_area += sqrt(
					uv_halfPerimeter * (uv_halfPerimeter - uv_a) * (uv_halfPerimeter - uv_b) * (uv_halfPerimeter - uv_c));
		}
	}

	if (uv_area < 0.0001f) {
		uv_area = 1.0;
	}

	int pixels = Math::round(ceil((1.0 / sqrt(uv_area)) * sqrt(area * default_texels_per_unit)));
	int size = CLAMP(pixels, 2, 4096);
	return Vector2i(size, size);
}

void BakedLightmap::_find_meshes_and_lights(Node *p_at_node, Vector<MeshesFound> &meshes, Vector<LightsFound> &lights) {
	AABB bounds = AABB(-extents, extents * 2.0);

	MeshInstance *mi = Object::cast_to<MeshInstance>(p_at_node);
	if (mi && mi->get_flag(GeometryInstance::FLAG_USE_BAKED_LIGHT) && mi->is_visible_in_tree()) {
		Ref<Mesh> mesh = mi->get_mesh();
		if (mesh.is_valid()) {
			bool all_have_uv2_and_normal = true;
			bool surfaces_found = false;
			for (int i = 0; i < mesh->get_surface_count(); i++) {
				if (mesh->surface_get_primitive_type(i) != Mesh::PRIMITIVE_TRIANGLES) {
					continue;
				}
				if (!(mesh->surface_get_format(i) & Mesh::ARRAY_FORMAT_TEX_UV2)) {
					all_have_uv2_and_normal = false;
					break;
				}
				if (!(mesh->surface_get_format(i) & Mesh::ARRAY_FORMAT_NORMAL)) {
					all_have_uv2_and_normal = false;
					break;
				}
				surfaces_found = true;
			}

			if (surfaces_found && all_have_uv2_and_normal) {
				Transform mesh_xform = get_global_transform().affine_inverse() * mi->get_global_transform();

				AABB aabb = mesh_xform.xform(mesh->get_aabb());

				if (bounds.intersects(aabb)) {
					MeshesFound mf;
					mf.cast_shadows = mi->get_cast_shadows_setting() != GeometryInstance::SHADOW_CASTING_SETTING_OFF;
					mf.generate_lightmap = mi->get_generate_lightmap();
					mf.xform = mesh_xform;
					mf.node_path = get_path_to(mi);
					mf.subindex = -1;
					mf.mesh = mesh;

					static const int lightmap_scale[4] = { 1, 2, 4, 8 }; //GeometryInstance3D::LIGHTMAP_SCALE_MAX = { 1, 2, 4, 8 };
					mf.lightmap_scale = lightmap_scale[mi->get_lightmap_scale()];

					Ref<Material> all_override = mi->get_material_override();
					for (int i = 0; i < mesh->get_surface_count(); i++) {
						if (all_override.is_valid()) {
							mf.overrides.push_back(all_override);
						} else {
							mf.overrides.push_back(mi->get_surface_material(i));
						}
					}

					meshes.push_back(mf);
				}
			}
		}
	}

	Spatial *s = Object::cast_to<Spatial>(p_at_node);

	if (!mi && s) {
		Array bmeshes = p_at_node->call(""get_bake_meshes"");
		if (bmeshes.size() && (bmeshes.size() & 1) == 0) {
			Transform xf = get_global_transform().affine_inverse() * s->get_global_transform();
			Ref<Material> all_override;

			GeometryInstance *gi = Object::cast_to<GeometryInstance>(p_at_node);
			if (gi) {
				all_override = gi->get_material_override();
			}

			for (int i = 0; i < bmeshes.size(); i += 2) {
				Ref<Mesh> mesh = bmeshes[i];
				if (!mesh.is_valid()) {
					continue;
				}

				Transform mesh_xform = xf * bmeshes[i + 1];

				AABB aabb = mesh_xform.xform(mesh->get_aabb());

				if (!bounds.intersects(aabb)) {
					continue;
				}

				MeshesFound mf;
				mf.xform = mesh_xform;
				mf.node_path = get_path_to(s);
				mf.subindex = i / 2;
				mf.lightmap_scale = 1;
				mf.mesh = mesh;

				if (gi) {
					mf.cast_shadows = gi->get_cast_shadows_setting() != GeometryInstance::SHADOW_CASTING_SETTING_OFF;
					mf.generate_lightmap = gi->get_generate_lightmap();
				} else {
					mf.cast_shadows = true;
					mf.generate_lightmap = true;
				}

				for (int j = 0; j < mesh->get_surface_count(); j++) {
					mf.overrides.push_back(all_override);
				}

				meshes.push_back(mf);
			}
		}
	}

	Light *light = Object::cast_to<Light>(p_at_node);

	if (light && light->get_bake_mode() != Light::BAKE_DISABLED) {
		LightsFound lf;
		lf.xform = get_global_transform().affine_inverse() * light->get_global_transform();
		lf.light = light;
		lights.push_back(lf);
	}

	for (int i = 0; i < p_at_node->get_child_count(); i++) {
		Node *child = p_at_node->get_child(i);
		if (!child->get_owner()) {
			continue; //maybe a helper
		}

		_find_meshes_and_lights(child, meshes, lights);
	}
}

void BakedLightmap::_get_material_images(const MeshesFound &p_found_mesh, Lightmapper::MeshData &r_mesh_data, Vector<Ref<Texture>> &r_albedo_textures, Vector<Ref<Texture>> &r_emission_textures) {
	for (int i = 0; i < p_found_mesh.mesh->get_surface_count(); ++i) {
		Ref<SpatialMaterial> mat = p_found_mesh.overrides[i];

		if (mat.is_null()) {
			mat = p_found_mesh.mesh->surface_get_material(i);
		}

		Ref<Texture> albedo_texture;
		Color albedo_add = Color(1, 1, 1, 1);
		Color albedo_mul = Color(1, 1, 1, 1);

		Ref<Texture> emission_texture;
		Color emission_add = Color(0, 0, 0, 0);
		Color emission_mul = Color(1, 1, 1, 1);

		if (mat.is_valid()) {
			albedo_texture = mat->get_texture(SpatialMaterial::TEXTURE_ALBEDO);

			if (albedo_texture.is_valid()) {
				albedo_mul = mat->get_albedo();
				albedo_add = Color(0, 0, 0, 0);
			} else {
				albedo_add = mat->get_albedo();
			}

			emission_texture = mat->get_texture(SpatialMaterial::TEXTURE_EMISSION);
			Color emission_color = mat->get_emission();
			float emission_energy = mat->get_emission_energy();

			if (mat->get_emission_operator() == SpatialMaterial::EMISSION_OP_ADD) {
				emission_mul = Color(1, 1, 1) * emission_energy;
				emission_add = emission_color * emission_energy;
			} else {
				emission_mul = emission_color * emission_energy;
				emission_add = Color(0, 0, 0);
			}
		}

		Lightmapper::MeshData::TextureDef albedo;
		albedo.mul = albedo_mul;
		albedo.add = albedo_add;

		if (albedo_texture.is_valid()) {
			albedo.tex_rid = albedo_texture->get_rid();
			r_albedo_textures.push_back(albedo_texture);
		}

		r_mesh_data.albedo.push_back(albedo);

		Lightmapper::MeshData::TextureDef emission;
		emission.mul = emission_mul;
		emission.add = emission_add;

		if (emission_texture.is_valid()) {
			emission.tex_rid = emission_texture->get_rid();
			r_emission_textures.push_back(emission_texture);
		}
		r_mesh_data.emission.push_back(emission);
	}
}

void BakedLightmap::_save_image(String &r_base_path, Ref<Image> r_img, bool p_use_srgb) {
	if (use_hdr) {
		r_base_path += "".exr"";
	} else {
		r_base_path += "".png"";
	}

	String relative_path = r_base_path;
	if (relative_path.begins_with(""res://"")) {
		relative_path = relative_path.substr(6, relative_path.length());
	}

	bool hdr_grayscale = use_hdr && !use_color;

	r_img->lock();
	for (int i = 0; i < r_img->get_height(); i++) {
		for (int j = 0; j < r_img->get_width(); j++) {
			Color c = r_img->get_pixel(j, i);

			c.r = MAX(c.r, environment_min_light.r);
			c.g = MAX(c.g, environment_min_light.g);
			c.b = MAX(c.b, environment_min_light.b);

			if (hdr_grayscale) {
				c = Color(c.get_v(), 0.0f, 0.0f);
			}

			if (p_use_srgb) {
				c = c.to_srgb();
			}

			r_img->set_pixel(j, i, c);
		}
	}
	r_img->unlock();

	if (!use_color) {
		if (use_hdr) {
			r_img->convert(Image::FORMAT_RH);
		} else {
			r_img->convert(Image::FORMAT_L8);
		}
	}

	if (use_hdr) {
		r_img->save_exr(relative_path, !use_color);
	} else {
		r_img->save_png(relative_path);
	}
}

bool BakedLightmap::_lightmap_bake_step_function(float p_completion, const String &p_text, void *ud, bool p_refresh) {
	BakeStepUD *bsud = (BakeStepUD *)ud;
	bool ret = false;
	if (bsud->func) {
		ret = bsud->func(bsud->from_percent + p_completion * (bsud->to_percent - bsud->from_percent), p_text, bsud->ud, p_refresh);
	}
	return ret;
}

BakedLightmap::BakeError BakedLightmap::bake(Node *p_from_node, String p_data_save_path) {
	if (!p_from_node && !get_parent()) {
		return BAKE_ERROR_NO_ROOT;
	}

	bool no_save_path = false;
	if (p_data_save_path == """" && (get_light_data().is_null() || !get_light_data()->get_path().is_resource_file())) {
		no_save_path = true;
	}

	if (p_data_save_path == """") {
		if (get_light_data().is_null()) {
			no_save_path = true;
		} else {
			p_data_save_path = get_light_data()->get_path();
			if (!p_data_save_path.is_resource_file()) {
				no_save_path = true;
			}
		}
	}

	if (no_save_path) {
		if (image_path == """") {
			return BAKE_ERROR_NO_SAVE_PATH;
		} else {
			p_data_save_path = image_path;
		}

		WARN_PRINT(""Using the deprecated property \\""image_path\\"" as a save path, consider providing a better save path via the \\""data_save_path\\"" parameter"");
		p_data_save_path = image_path.plus_file(""BakedLightmap.lmbake"");
	}

	{
		//check for valid save path
		DirAccessRef d = DirAccess::open(p_data_save_path.get_base_dir());
		if (!d) {
			ERR_FAIL_V_MSG(BAKE_ERROR_NO_SAVE_PATH, ""Invalid save path '"" + p_data_save_path + ""'."");
		}
	}

	uint32_t time_started = OS::get_singleton()->get_ticks_msec();

	if (bake_step_function) {
		bool cancelled = bake_step_function(0.0, TTR(""Finding meshes and lights""), nullptr, true);
		if (cancelled) {
			bake_end_function(time_started);
			return BAKE_ERROR_USER_ABORTED;
		}
	}

	Ref<Lightmapper> lightmapper = Lightmapper::create();
	if (lightmapper.is_null()) {
		bake_end_function(time_started);
		return BAKE_ERROR_NO_LIGHTMAPPER;
	}

	Vector<LightsFound> lights_found;
	Vector<MeshesFound> meshes_found;

	_find_meshes_and_lights(p_from_node ? p_from_node : get_parent(), meshes_found, lights_found);

	if (meshes_found.size() == 0) {
		bake_end_function(time_started);
		return BAKE_ERROR_NO_MESHES;
	}

	for (int m_i = 0; m_i < meshes_found.size(); m_i++) {
		if (bake_step_function) {
			float p = (float)(m_i) / meshes_found.size();
			bool cancelled = bake_step_function(p * 0.05, vformat(TTR(""Preparing geometry (%d/%d)""), m_i + 1, meshes_found.size()), nullptr, false);
			if (cancelled) {
				bake_end_function(time_started);
				return BAKE_ERROR_USER_ABORTED;
			}
		}

		MeshesFound &mf = meshes_found.write[m_i];

		Size2i lightmap_size = mf.mesh->get_lightmap_size_hint();

		if (lightmap_size == Vector2i(0, 0)) {
			lightmap_size = _compute_lightmap_size(mf);
		}
		lightmap_size *= mf.lightmap_scale;

		Lightmapper::MeshData md;

		{
			Dictionary d;
			d[""path""] = mf.node_path;
			if (mf.subindex >= 0) {
				d[""subindex""] = mf.subindex;
			}
			d[""cast_shadows""] = mf.cast_shadows;
			d[""generate_lightmap""] = mf.generate_lightmap;
			d[""node_name""] = mf.node_path.get_name(mf.node_path.get_name_count() - 1);
			md.userdata = d;
		}

		Basis normal_xform = mf.xform.basis.inverse().transposed();

		for (int i = 0; i < mf.mesh->get_surface_count(); i++) {
			if (mf.mesh->surface_get_primitive_type(i) != Mesh::PRIMITIVE_TRIANGLES) {
				continue;
			}
			Array a = mf.mesh->surface_get_arrays(i);

			Vector<Vector3> vertices = a[Mesh::ARRAY_VERTEX];
			const Vector3 *vr = vertices.ptr();
			Vector<Vector2> uv2 = a[Mesh::ARRAY_TEX_UV2];
			const Vector2 *uv2r = nullptr;
			Vector<Vector2> uv = a[Mesh::ARRAY_TEX_UV];
			const Vector2 *uvr = nullptr;
			Vector<Vector3> normals = a[Mesh::ARRAY_NORMAL];
			const Vector3 *nr = nullptr;
			Vector<int> index = a[Mesh::ARRAY_INDEX];

			ERR_CONTINUE(uv2.size() == 0);
			ERR_CONTINUE(normals.size() == 0);

			if (!uv.empty()) {
				uvr = uv.ptr();
			}

			uv2r = uv2.ptr();
			nr = normals.ptr();

			int facecount;
			const int *ir = nullptr;

			if (index.size()) {
				facecount = index.size() / 3;
				ir = index.ptr();
			} else {
				facecount = vertices.size() / 3;
			}

			md.surface_facecounts.push_back(facecount);

			for (int j = 0; j < facecount; j++) {
				uint32_t vidx[3];

				if (ir) {
					for (int k = 0; k < 3; k++) {
						vidx[k] = ir[j * 3 + k];
					}
				} else {
					for (int k = 0; k < 3; k++) {
						vidx[k] = j * 3 + k;
					}
				}

				for (int k = 0; k < 3; k++) {
					Vector3 v = mf.xform.xform(vr[vidx[k]]);
					md.points.push_back(v);

					md.uv2.push_back(uv2r[vidx[k]]);
					md.normal.push_back(normal_xform.xform(nr[vidx[k]]).normalized());

					if (uvr != nullptr) {
						md.uv.push_back(uvr[vidx[k]]);
					}
				}
			}
		}

		Vector<Ref<Texture>> albedo_textures;
		Vector<Ref<Texture>> emission_textures;

		_get_material_images(mf, md, albedo_textures, emission_textures);

		for (int j = 0; j < albedo_textures.size(); j++) {
			lightmapper->add_albedo_texture(albedo_textures[j]);
		}

		for (int j = 0; j < emission_textures.size(); j++) {
			lightmapper->add_emission_texture(emission_textures[j]);
		}

		lightmapper->add_mesh(md, lightmap_size);
	}

	for (int i = 0; i < lights_found.size(); i++) {
		Light *light = lights_found[i].light;
		Transform xf = lights_found[i].xform;

		if (Object::cast_to<DirectionalLight>(light)) {
			DirectionalLight *l = Object::cast_to<DirectionalLight>(light);
			lightmapper->add_directional_light(light->get_bake_mode() == Light::BAKE_ALL, -xf.basis.get_axis(Vector3::AXIS_Z).normalized(), l->get_color(), l->get_param(Light::PARAM_ENERGY), l->get_param(Light::PARAM_INDIRECT_ENERGY), l->get_param(Light::PARAM_SIZE));
		} else if (Object::cast_to<OmniLight>(light)) {
			OmniLight *l = Object::cast_to<OmniLight>(light);
			lightmapper->add_omni_light(light->get_bake_mode() == Light::BAKE_ALL, xf.origin, l->get_color(), l->get_param(Light::PARAM_ENERGY), l->get_param(Light::PARAM_INDIRECT_ENERGY), l->get_param(Light::PARAM_RANGE), l->get_param(Light::PARAM_ATTENUATION), l->get_param(Light::PARAM_SIZE));
		} else if (Object::cast_to<SpotLight>(light)) {
			SpotLight *l = Object::cast_to<SpotLight>(light);
			lightmapper->add_spot_light(light->get_bake_mode() == Light::BAKE_ALL, xf.origin, -xf.basis.get_axis(Vector3::AXIS_Z).normalized(), l->get_color(), l->get_param(Light::PARAM_ENERGY), l->get_param(Light::PARAM_INDIRECT_ENERGY), l->get_param(Light::PARAM_RANGE), l->get_param(Light::PARAM_ATTENUATION), l->get_param(Light::PARAM_SPOT_ANGLE), l->get_param(Light::PARAM_SPOT_ATTENUATION), l->get_param(Light::PARAM_SIZE));
		}
	}

	Ref<Image> environment_image;
	Basis environment_xform;

	if (environment_mode != ENVIRONMENT_MODE_DISABLED) {
		if (bake_step_function) {
			bake_step_function(0.1, TTR(""Preparing environment""), nullptr, true);
		}

		switch (environment_mode) {
			case ENVIRONMENT_MODE_DISABLED: {
				//nothing
			} break;
			case ENVIRONMENT_MODE_SCENE: {
				Ref<World> world = get_world();
				if (world.is_valid()) {
					Ref<Environment> env = world->get_environment();
					if (env.is_null()) {
						env = world->get_fallback_environment();
					}

					if (env.is_valid()) {
						environment_image = _get_irradiance_map(env, Vector2i(128, 64));
						environment_xform = get_global_transform().affine_inverse().basis * env->get_sky_orientation();
					}
				}
			} break;
			case ENVIRONMENT_MODE_CUSTOM_SKY: {
				if (environment_custom_sky.is_valid()) {
					environment_image = _get_irradiance_from_sky(environment_custom_sky, environment_custom_energy, Vector2i(128, 64));
					environment_xform.set_euler(environment_custom_sky_rotation_degrees * Math_PI / 180.0);
				}

			} break;
			case ENVIRONMENT_MODE_CUSTOM_COLOR: {
				environment_image.instance();
				environment_image->create(128, 64, false, Image::FORMAT_RGBF);
				Color c = environment_custom_color;
				c.r *= environment_custom_energy;
				c.g *= environment_custom_energy;
				c.b *= environment_custom_energy;
				environment_image->lock();
				for (int i = 0; i < 128; i++) {
					for (int j = 0; j < 64; j++) {
						environment_image->set_pixel(i, j, c);
					}
				}
				environment_image->unlock();
			} break;
		}
	}

	BakeStepUD bsud;
	bsud.func = bake_step_function;
	bsud.ud = nullptr;
	bsud.from_percent = 0.1;
	bsud.to_percent = 0.9;

	bool gen_atlas = OS::get_singleton()->get_current_video_driver() == OS::VIDEO_DRIVER_GLES2 ? false : generate_atlas;

	Lightmapper::BakeError bake_err = lightmapper->bake(Lightmapper::BakeQuality(bake_quality), use_denoiser, bounces, bounce_indirect_energy, bias, gen_atlas, max_atlas_size, environment_image, environment_xform, _lightmap_bake_step_function, &bsud, bake_substep_function);

	if (bake_err != Lightmapper::BAKE_OK) {
		bake_end_function(time_started);
		switch (bake_err) {
			case Lightmapper::BAKE_ERROR_USER_ABORTED: {
				return BAKE_ERROR_USER_ABORTED;
			}
			case Lightmapper::BAKE_ERROR_LIGHTMAP_TOO_SMALL: {
				return BAKE_ERROR_LIGHTMAP_SIZE;
			}
			case Lightmapper::BAKE_ERROR_NO_MESHES: {
				return BAKE_ERROR_NO_MESHES;
			}
			default: {
			}
		}
		return BAKE_ERROR_NO_LIGHTMAPPER;
	}

	Ref<BakedLightmapData> data;
	if (get_light_data().is_valid()) {
		data = get_light_data();
		set_light_data(Ref<BakedLightmapData>()); //clear
		data->clear_data();
	} else {
		data.instance();
	}

	if (capture_enabled) {
		if (bake_step_function) {
			bool cancelled = bake_step_function(0.85, TTR(""Generating capture""), nullptr, true);
			if (cancelled) {
				bake_end_function(time_started);
				return BAKE_ERROR_USER_ABORTED;
			}
		}

		VoxelLightBaker voxel_baker;

		int bake_subdiv;
		int capture_subdiv;
		AABB bake_bounds;
		{
			bake_bounds = AABB(-extents, extents * 2.0);
			int subdiv = nearest_power_of_2_templated(int(bake_bounds.get_longest_axis_size() / capture_cell_size));
			bake_bounds.size[bake_bounds.get_longest_axis_index()] = subdiv * capture_cell_size;
			bake_subdiv = nearest_shift(subdiv) + 1;

			capture_subdiv = bake_subdiv;
			float css = capture_cell_size;
			while (css < capture_cell_size && capture_subdiv > 2) {
				capture_subdiv--;
				css *= 2.0;
			}
		}

		voxel_baker.begin_bake(capture_subdiv + 1, bake_bounds);

		for (int mesh_id = 0; mesh_id < meshes_found.size(); mesh_id++) {
			MeshesFound &mf = meshes_found.write[mesh_id];
			voxel_baker.plot_mesh(mf.xform, mf.mesh, mf.overrides, Ref<Material>());
		}

		VoxelLightBaker::BakeQuality capt_quality = VoxelLightBaker::BakeQuality::BAKE_QUALITY_HIGH;
		if (capture_quality == BakedLightmap::BakeQuality::BAKE_QUALITY_LOW) {
			capt_quality = VoxelLightBaker::BakeQuality::BAKE_QUALITY_LOW;
		} else if (capture_quality == BakedLightmap::BakeQuality::BAKE_QUALITY_MEDIUM) {
			capt_quality = VoxelLightBaker::BakeQuality::BAKE_QUALITY_MEDIUM;
		}

		voxel_baker.begin_bake_light(capt_quality, capture_propagation);

		for (int i = 0; i < lights_found.size(); i++) {
			LightsFound &lf = lights_found.write[i];
			switch (lf.light->get_light_type()) {
				case VS::LIGHT_DIRECTIONAL: {
					voxel_baker.plot_light_directional(-lf.xform.basis.get_axis(2), lf.light->get_color(), lf.light->get_param(Light::PARAM_ENERGY), lf.light->get_param(Light::PARAM_INDIRECT_ENERGY), lf.light->get_bake_mode() == Light::BAKE_ALL);
				} break;
				case VS::LIGHT_OMNI: {
					voxel_baker.plot_light_omni(lf.xform.origin, lf.light->get_color(), lf.light->get_param(Light::PARAM_ENERGY), lf.light->get_param(Light::PARAM_INDIRECT_ENERGY), lf.light->get_param(Light::PARAM_RANGE), lf.light->get_param(Light::PARAM_ATTENUATION), lf.light->get_bake_mode() == Light::BAKE_ALL);
				} break;
				case VS::LIGHT_SPOT: {
					voxel_baker.plot_light_spot(lf.xform.origin, lf.xform.basis.get_axis(2), lf.light->get_color(), lf.light->get_param(Light::PARAM_ENERGY), lf.light->get_param(Light::PARAM_INDIRECT_ENERGY), lf.light->get_param(Light::PARAM_RANGE), lf.light->get_param(Light::PARAM_ATTENUATION), lf.light->get_param(Light::PARAM_SPOT_ANGLE), lf.light->get_param(Light::PARAM_SPOT_ATTENUATION), lf.light->get_bake_mode() == Light::BAKE_ALL);

				} break;
			}
		}

		voxel_baker.end_bake();

		AABB bounds = AABB(-extents, extents * 2);
		data->set_cell_subdiv(capture_subdiv);
		data->set_bounds(bounds);
		data->set_octree(voxel_baker.create_capture_octree(capture_subdiv));

		{
			float bake_bound_size = bake_bounds.get_longest_axis_size();
			Transform to_bounds;
			to_bounds.basis.scale(Vector3(bake_bound_size, bake_bound_size, bake_bound_size));
			to_bounds.origin = bounds.position;

			Transform to_grid;
			to_grid.basis.scale(Vector3(1 << (capture_subdiv - 1), 1 << (capture_subdiv - 1), 1 << (capture_subdiv - 1)));

			Transform to_cell_space = to_grid * to_bounds.affine_inverse();
			data->set_cell_space_transform(to_cell_space);
		}
	}

	if (bake_step_function) {
		bool cancelled = bake_step_function(0.9, TTR(""Saving lightmaps""), nullptr, true);
		if (cancelled) {
			bake_end_function(time_started);
			return BAKE_ERROR_USER_ABORTED;
		}
	}

	Vector<Ref<Image>> images;
	for (int i = 0; i < lightmapper->get_bake_texture_count(); i++) {
		images.push_back(lightmapper->get_bake_texture(i));
	}

	bool use_srgb = use_color && !use_hdr;

	if (gen_atlas) {
		int slice_count = images.size();
		int slice_width = images[0]->get_width();
		int slice_height = images[0]->get_height();

		int slices_per_texture = Image::MAX_HEIGHT / slice_height;
		int texture_count = Math::ceil(slice_count / (float)slices_per_texture);

		Vector<Ref<TextureLayered>> textures;
		textures.resize(texture_count);
		String base_path = p_data_save_path.get_basename();

		int last_count = slice_count % slices_per_texture;
		for (int i = 0; i < texture_count; i++) {
			String texture_path = texture_count > 1 ? base_path + ""_"" + itos(i) : base_path;
			int texture_slice_count = (i == texture_count - 1 && last_count != 0) ? last_count : slices_per_texture;

			Ref<Image> large_image;
			large_image.instance();
			large_image->create(slice_width, slice_height * texture_slice_count, false, images[0]->get_format());

			for (int j = 0; j < texture_slice_count; j++) {
				large_image->blit_rect(images[i * slices_per_texture + j], Rect2(0, 0, slice_width, slice_height), Point2(0, slice_height * j));
			}
			_save_image(texture_path, large_image, use_srgb);

			Ref<ConfigFile> config;
			config.instance();
			if (FileAccess::exists(texture_path + "".import"")) {
				config->load(texture_path + "".import"");
			} else {
				// Set only if settings don't exist, to keep user choice
				config->set_value(""params"", ""compress/mode"", 0);
			}
			config->set_value(""remap"", ""importer"", ""texture_array"");
			config->set_value(""remap"", ""type"", ""TextureArray"");
			config->set_value(""params"", ""detect_3d"", false);
			config->set_value(""params"", ""flags/repeat"", false);
			config->set_value(""params"", ""flags/filter"", true);
			config->set_value(""params"", ""flags/mipmaps"", false);
			config->set_value(""params"", ""flags/srgb"", use_srgb);
			config->set_value(""params"", ""slices/horizontal"", 1);
			config->set_value(""params"", ""slices/vertical"", texture_slice_count);

			config->save(texture_path + "".import"");

			ResourceLoader::import(texture_path);
			textures.write[i] = ResourceLoader::load(texture_path); //if already loaded, it will be updated on refocus?
		}

		for (int i = 0; i < lightmapper->get_bake_mesh_count(); i++) {
			if (!meshes_found[i].generate_lightmap) {
				continue;
			}
			Dictionary d = lightmapper->get_bake_mesh_userdata(i);
			NodePath np = d[""path""];
			int32_t subindex = -1;
			if (d.has(""subindex"")) {
				subindex = d[""subindex""];
			}

			Rect2 uv_rect = lightmapper->get_bake_mesh_uv_scale(i);
			int slice_index = lightmapper->get_bake_mesh_texture_slice(i);
			data->add_user(np, textures[slice_index / slices_per_texture], slice_index % slices_per_texture, uv_rect, subindex);
		}
	} else {
		for (int i = 0; i < lightmapper->get_bake_mesh_count(); i++) {
			if (!meshes_found[i].generate_lightmap) {
				continue;
			}

			Ref<Texture> texture;
			String base_path = p_data_save_path.get_base_dir().plus_file(images[i]->get_name());

			if (ResourceLoader::import) {
				_save_image(base_path, images[i], use_srgb);

				Ref<ConfigFile> config;
				config.instance();
				if (FileAccess::exists(base_path + "".import"")) {
					config->load(base_path + "".import"");
				} else {
					// Set only if settings don't exist, to keep user choice
					config->set_value(""params"", ""compress/mode"", 0);
				}
				config->set_value(""remap"", ""importer"", ""texture"");
				config->set_value(""remap"", ""type"", ""StreamTexture"");
				config->set_value(""params"", ""detect_3d"", false);
				config->set_value(""params"", ""flags/repeat"", false);
				config->set_value(""params"", ""flags/filter"", true);
				config->set_value(""params"", ""flags/mipmaps"", false);
				config->set_value(""params"", ""flags/srgb"", use_srgb);

				config->save(base_path + "".import"");

				ResourceLoader::import(base_path);
				texture = ResourceLoader::load(base_path); //if already loaded, it will be updated on refocus?
			} else {
				base_path += "".tex"";
				Ref<ImageTexture> tex;
				bool set_path = true;
				if (ResourceCache::has(base_path)) {
					tex = Ref<Resource>((Resource *)ResourceCache::get(base_path));
					set_path = false;
				}

				if (!tex.is_valid()) {
					tex.instance();
				}

				tex->create_from_image(images[i], Texture::FLAGS_DEFAULT);

				ResourceSaver::save(base_path, tex, ResourceSaver::FLAG_CHANGE_PATH);
				if (set_path) {
					tex->set_path(base_path);
				}
				texture = tex;
			}

			Dictionary d = lightmapper->get_bake_mesh_userdata(i);
			NodePath np = d[""path""];
			int32_t subindex = -1;
			if (d.has(""subindex"")) {
				subindex = d[""subindex""];
			}

			Rect2 uv_rect = Rect2(0, 0, 1, 1);
			int slice_index = -1;
			data->add_user(np, texture, slice_index, uv_rect, subindex);
		}
	}

	if (bake_step_function) {
		bool cancelled = bake_step_function(1.0, TTR(""Done""), nullptr, true);
		if (cancelled) {
			bake_end_function(time_started);
			return BAKE_ERROR_USER_ABORTED;
		}
	}

	Error err = ResourceSaver::save(p_data_save_path, data);
	data->set_path(p_data_save_path);

	if (err != OK) {
		bake_end_function(time_started);
		return BAKE_ERROR_CANT_CREATE_IMAGE;
	}

	set_light_data(data);
	bake_end_function(time_started);

	return BAKE_ERROR_OK;
}

void BakedLightmap::set_capture_cell_size(float p_cell_size) {
	capture_cell_size = MAX(0.1, p_cell_size);
}

float BakedLightmap::get_capture_cell_size() const {
	return capture_cell_size;
}

void BakedLightmap::set_extents(const Vector3 &p_extents) {
	extents = p_extents;
	update_gizmo();
	_change_notify(""extents"");
}

Vector3 BakedLightmap::get_extents() const {
	return extents;
}

void BakedLightmap::set_default_texels_per_unit(const float &p_bake_texels_per_unit) {
	default_texels_per_unit = MAX(0.0, p_bake_texels_per_unit);
}

float BakedLightmap::get_default_texels_per_unit() const {
	return default_texels_per_unit;
}

void BakedLightmap::set_capture_enabled(bool p_enable) {
	capture_enabled = p_enable;
	_change_notify();
}

bool BakedLightmap::get_capture_enabled() const {
	return capture_enabled;
}

void BakedLightmap::_notification(int p_what) {
	if (p_what == NOTIFICATION_READY) {
		if (light_data.is_valid()) {
			_assign_lightmaps();
		}
		request_ready(); //will need ready again if re-enters tree
	}

	if (p_what == NOTIFICATION_EXIT_TREE) {
		if (light_data.is_valid()) {
			_clear_lightmaps();
		}
	}
}

void BakedLightmap::_assign_lightmaps() {
	ERR_FAIL_COND(!light_data.is_valid());

	bool atlassed_on_gles2 = false;

	for (int i = 0; i < light_data->get_user_count(); i++) {
		Ref<Resource> lightmap = light_data->get_user_lightmap(i);
		ERR_CONTINUE(!lightmap.is_valid());
		ERR_CONTINUE(!Object::cast_to<Texture>(lightmap.ptr()) && !Object::cast_to<TextureLayered>(lightmap.ptr()));

		Node *node = get_node(light_data->get_user_path(i));
		int instance_idx = light_data->get_user_instance(i);
		if (instance_idx >= 0) {
			RID instance = node->call(""get_bake_mesh_instance"", instance_idx);
			if (instance.is_valid()) {
				int slice = light_data->get_user_lightmap_slice(i);
				atlassed_on_gles2 = atlassed_on_gles2 || (slice != -1 && OS::get_singleton()->get_current_video_driver() == OS::VIDEO_DRIVER_GLES2);
				VS::get_singleton()->instance_set_use_lightmap(instance, get_instance(), lightmap->get_rid(), slice, light_data->get_user_lightmap_uv_rect(i));
			}
		} else {
			VisualInstance *vi = Object::cast_to<VisualInstance>(node);
			ERR_CONTINUE(!vi);
			int slice = light_data->get_user_lightmap_slice(i);
			atlassed_on_gles2 = atlassed_on_gles2 || (slice != -1 && OS::get_singleton()->get_current_video_driver() == OS::VIDEO_DRIVER_GLES2);
			VS::get_singleton()->instance_set_use_lightmap(vi->get_instance(), get_instance(), lightmap->get_rid(), slice, light_data->get_user_lightmap_uv_rect(i));
		}
	}

	if (atlassed_on_gles2) {
		ERR_PRINT(""GLES2 doesn't support layered textures, so lightmap atlassing is not supported. Please re-bake the lightmap or switch to GLES3."");
	}
}

void BakedLightmap::_clear_lightmaps() {
	ERR_FAIL_COND(!light_data.is_valid());
	for (int i = 0; i < light_data->get_user_count(); i++) {
		Node *node = get_node(light_data->get_user_path(i));
		int instance_idx = light_data->get_user_instance(i);
		if (instance_idx >= 0) {
			RID instance = node->call(""get_bake_mesh_instance"", instance_idx);
			if (instance.is_valid()) {
				VS::get_singleton()->instance_set_use_lightmap(instance, get_instance(), RID(), -1, Rect2(0, 0, 1, 1));
			}
		} else {
			VisualInstance *vi = Object::cast_to<VisualInstance>(node);
			ERR_CONTINUE(!vi);
			VS::get_singleton()->instance_set_use_lightmap(vi->get_instance(), get_instance(), RID(), -1, Rect2(0, 0, 1, 1));
		}
	}
}

Ref<Image> BakedLightmap::_get_irradiance_from_sky(Ref<Sky> p_sky, float p_energy, Vector2i p_size) {
	if (p_sky.is_null()) {
		return Ref<Image>();
	}

	Ref<Image> sky_image;
	Ref<PanoramaSky> panorama = p_sky;
	if (panorama.is_valid()) {
		sky_image = panorama->get_panorama()->get_data();
	}
	Ref<ProceduralSky> procedural = p_sky;
	if (procedural.is_valid()) {
		sky_image = procedural->get_data();
	}

	if (sky_image.is_null()) {
		return Ref<Image>();
	}

	sky_image->convert(Image::FORMAT_RGBF);
	sky_image->resize(p_size.x, p_size.y, Image::INTERPOLATE_CUBIC);

	if (p_energy != 1.0) {
		sky_image->lock();
		for (int i = 0; i < p_size.y; i++) {
			for (int j = 0; j < p_size.x; j++) {
				sky_image->set_pixel(j, i, sky_image->get_pixel(j, i) * p_energy);
			}
		}
		sky_image->unlock();
	}

	return sky_image;
}

Ref<Image> BakedLightmap::_get_irradiance_map(Ref<Environment> p_env, Vector2i p_size) {
	Environment::BGMode bg_mode = p_env->get_background();
	switch (bg_mode) {
		case Environment::BG_SKY: {
			return _get_irradiance_from_sky(p_env->get_sky(), p_env->get_bg_energy(), Vector2i(128, 64));
		}
		case Environment::BG_CLEAR_COLOR:
		case Environment::BG_COLOR: {
			Color c = bg_mode == Environment::BG_CLEAR_COLOR ? Color(GLOBAL_GET(""rendering/environment/default_clear_color"")) : p_env->get_bg_color();
			c.r *= p_env->get_bg_energy();
			c.g *= p_env->get_bg_energy();
			c.b *= p_env->get_bg_energy();

			Ref<Image> ret;
			ret.instance();
			ret->create(p_size.x, p_size.y, false, Image::FORMAT_RGBF);
			ret->fill(c);
			return ret;
		}
		default: {
		}
	}
	return Ref<Image>();
}

void BakedLightmap::set_light_data(const Ref<BakedLightmapData> &p_data) {
	if (light_data.is_valid()) {
		if (is_inside_tree()) {
			_clear_lightmaps();
		}
		set_base(RID());
	}
	light_data = p_data;
	_change_notify();

	if (light_data.is_valid()) {
		set_base(light_data->get_rid());
		if (is_inside_tree()) {
			_assign_lightmaps();
		}
	}
}

Ref<BakedLightmapData> BakedLightmap::get_light_data() const {
	return light_data;
}

void BakedLightmap::set_capture_propagation(float p_propagation) {
	capture_propagation = p_propagation;
}

float BakedLightmap::get_capture_propagation() const {
	return capture_propagation;
}

void BakedLightmap::set_capture_quality(BakeQuality p_quality) {
	capture_quality = p_quality;
}

BakedLightmap::BakeQuality BakedLightmap::get_capture_quality() const {
	return capture_quality;
}

void BakedLightmap::set_generate_atlas(bool p_enabled) {
	generate_atlas = p_enabled;
}

bool BakedLightmap::is_generate_atlas_enabled() const {
	return generate_atlas;
}

void BakedLightmap::set_max_atlas_size(int p_size) {
	ERR_FAIL_COND(p_size < 2048);
	max_atlas_size = p_size;
}

int BakedLightmap::get_max_atlas_size() const {
	return max_atlas_size;
}

void BakedLightmap::set_bake_quality(BakeQuality p_quality) {
	bake_quality = p_quality;
	_change_notify();
}

BakedLightmap::BakeQuality BakedLightmap::get_bake_quality() const {
	return bake_quality;
}

#ifndef DISABLE_DEPRECATED
void BakedLightmap::set_image_path(const String &p_path) {
	image_path = p_path;
}

String BakedLightmap::get_image_path() const {
	return image_path;
}
#endif

void BakedLightmap::set_use_denoiser(bool p_enable) {
	use_denoiser = p_enable;
}

bool BakedLightmap::is_using_denoiser() const {
	return use_denoiser;
}

void BakedLightmap::set_use_hdr(bool p_enable) {
	use_hdr = p_enable;
}

bool BakedLightmap::is_using_hdr() const {
	return use_hdr;
}

void BakedLightmap::set_use_color(bool p_enable) {
	use_color = p_enable;
}

bool BakedLightmap::is_using_color() const {
	return use_color;
}

void BakedLightmap::set_environment_mode(EnvironmentMode p_mode) {
	environment_mode = p_mode;
	_change_notify();
}

BakedLightmap::EnvironmentMode BakedLightmap::get_environment_mode() const {
	return environment_mode;
}

void BakedLightmap::set_environment_custom_sky(const Ref<Sky> &p_sky) {
	environment_custom_sky = p_sky;
}

Ref<Sky> BakedLightmap::get_environment_custom_sky() const {
	return environment_custom_sky;
}

void BakedLightmap::set_environment_custom_sky_rotation_degrees(const Vector3 &p_rotation) {
	environment_custom_sky_rotation_degrees = p_rotation;
}

Vector3 BakedLightmap::get_environment_custom_sky_rotation_degrees() const {
	return environment_custom_sky_rotation_degrees;
}

void BakedLightmap::set_environment_custom_color(const Color &p_color) {
	environment_custom_color = p_color;
}
Color BakedLightmap::get_environment_custom_color() const {
	return environment_custom_color;
}

void BakedLightmap::set_environment_custom_energy(float p_energy) {
	environment_custom_energy = p_energy;
}
float BakedLightmap::get_environment_custom_energy() const {
	return environment_custom_energy;
}

void BakedLightmap::set_environment_min_light(Color p_min_light) {
	environment_min_light = p_min_light;
}

Color BakedLightmap::get_environment_min_light() const {
	return environment_min_light;
}

void BakedLightmap::set_bounces(int p_bounces) {
	ERR_FAIL_COND(p_bounces < 0 || p_bounces > 16);
	bounces = p_bounces;
}

int BakedLightmap::get_bounces() const {
	return bounces;
}

void BakedLightmap::set_bounce_indirect_energy(float p_indirect_energy) {
	ERR_FAIL_COND(p_indirect_energy < 0.0);
	bounce_indirect_energy = p_indirect_energy;
}

float BakedLightmap::get_bounce_indirect_energy() const {
	return bounce_indirect_energy;
}

void BakedLightmap::set_bias(float p_bias) {
	ERR_FAIL_COND(p_bias < 0.00001f);
	bias = p_bias;
}

float BakedLightmap::get_bias() const {
	return bias;
}

AABB BakedLightmap::get_aabb() const {
	return AABB(-extents, extents * 2);
}
PoolVector<Face3> BakedLightmap::get_faces(uint32_t p_usage_flags) const {
	return PoolVector<Face3>();
}

void BakedLightmap::_validate_property(PropertyInfo &property) const {
	if (property.name.begins_with(""environment_custom_sky"") && environment_mode != ENVIRONMENT_MODE_CUSTOM_SKY) {
		property.usage = 0;
	}

	if (property.name == ""environment_custom_color"" && environment_mode != ENVIRONMENT_MODE_CUSTOM_COLOR) {
		property.usage = 0;
	}

	if (property.name == ""environment_custom_energy"" && environment_mode != ENVIRONMENT_MODE_CUSTOM_COLOR && environment_mode != ENVIRONMENT_MODE_CUSTOM_SKY) {
		property.usage = 0;
	}

	if (property.name.begins_with(""atlas"") && OS::get_singleton()->get_current_video_driver() == OS::VIDEO_DRIVER_GLES2) {
		property.usage = PROPERTY_USAGE_NOEDITOR;
	}

	if (property.name.begins_with(""capture"") && property.name != ""capture_enabled"" && !capture_enabled) {
		property.usage = 0;
	}
}

void BakedLightmap::_bind_methods() {
	ClassDB::bind_method(D_METHOD(""set_light_data"", ""data""), &BakedLightmap::set_light_data);
	ClassDB::bind_method(D_METHOD(""get_light_data""), &BakedLightmap::get_light_data);

	ClassDB::bind_method(D_METHOD(""set_bake_quality"", ""quality""), &BakedLightmap::set_bake_quality);
	ClassDB::bind_method(D_METHOD(""get_bake_quality""), &BakedLightmap::get_bake_quality);

	ClassDB::bind_method(D_METHOD(""set_bounces"", ""bounces""), &BakedLightmap::set_bounces);
	ClassDB::bind_method(D_METHOD(""get_bounces""), &BakedLightmap::get_bounces);

	ClassDB::bind_method(D_METHOD(""set_bounce_indirect_energy"", ""bounce_indirect_energy""), &BakedLightmap::set_bounce_indirect_energy);
	ClassDB::bind_method(D_METHOD(""get_bounce_indirect_energy""), &BakedLightmap::get_bounce_indirect_energy);

	ClassDB::bind_method(D_METHOD(""set_bias"", ""bias""), &BakedLightmap::set_bias);
	ClassDB::bind_method(D_METHOD(""get_bias""), &BakedLightmap::get_bias);

	ClassDB::bind_method(D_METHOD(""set_environment_mode"", ""mode""), &BakedLightmap::set_environment_mode);
	ClassDB::bind_method(D_METHOD(""get_environment_mode""), &BakedLightmap::get_environment_mode);

	ClassDB::bind_method(D_METHOD(""set_environment_custom_sky"", ""sky""), &BakedLightmap::set_environment_custom_sky);
	ClassDB::bind_method(D_METHOD(""get_environment_custom_sky""), &BakedLightmap::get_environment_custom_sky);

	ClassDB::bind_method(D_METHOD(""set_environment_custom_sky_rotation_degrees"", ""rotation""), &BakedLightmap::set_environment_custom_sky_rotation_degrees);
	ClassDB::bind_method(D_METHOD(""get_environment_custom_sky_rotation_degrees""), &BakedLightmap::get_environment_custom_sky_rotation_degrees);

	ClassDB::bind_method(D_METHOD(""set_environment_custom_color"", ""color""), &BakedLightmap::set_environment_custom_color);
	ClassDB::bind_method(D_METHOD(""get_environment_custom_color""), &BakedLightmap::get_environment_custom_color);

	ClassDB::bind_method(D_METHOD(""set_environment_custom_energy"", ""energy""), &BakedLightmap::set_environment_custom_energy);
	ClassDB::bind_method(D_METHOD(""get_environment_custom_energy""), &BakedLightmap::get_environment_custom_energy);

	ClassDB::bind_method(D_METHOD(""set_environment_min_light"", ""min_light""), &BakedLightmap::set_environment_min_light);
	ClassDB::bind_method(D_METHOD(""get_environment_min_light""), &BakedLightmap::get_environment_min_light);

	ClassDB::bind_method(D_METHOD(""set_use_denoiser"", ""use_denoiser""), &BakedLightmap::set_use_denoiser);
	ClassDB::bind_method(D_METHOD(""is_using_denoiser""), &BakedLightmap::is_using_denoiser);

	ClassDB::bind_method(D_METHOD(""set_use_hdr"", ""use_denoiser""), &BakedLightmap::set_use_hdr);
	ClassDB::bind_method(D_METHOD(""is_using_hdr""), &BakedLightmap::is_using_hdr);

	ClassDB::bind_method(D_METHOD(""set_use_color"", ""use_denoiser""), &BakedLightmap::set_use_color);
	ClassDB::bind_method(D_METHOD(""is_using_color""), &BakedLightmap::is_using_color);

	ClassDB::bind_method(D_METHOD(""set_generate_atlas"", ""enabled""), &BakedLightmap::set_generate_atlas);
	ClassDB::bind_method(D_METHOD(""is_generate_atlas_enabled""), &BakedLightmap::is_generate_atlas_enabled);

	ClassDB::bind_method(D_METHOD(""set_max_atlas_size"", ""max_atlas_size""), &BakedLightmap::set_max_atlas_size);
	ClassDB::bind_method(D_METHOD(""get_max_atlas_size""), &BakedLightmap::get_max_atlas_size);

	ClassDB::bind_method(D_METHOD(""set_capture_quality"", ""capture_quality""), &BakedLightmap::set_capture_quality);
	ClassDB::bind_method(D_METHOD(""get_capture_quality""), &BakedLightmap::get_capture_quality);

	ClassDB::bind_method(D_METHOD(""set_extents"", ""extents""), &BakedLightmap::set_extents);
	ClassDB::bind_method(D_METHOD(""get_extents""), &BakedLightmap::get_extents);

	ClassDB::bind_method(D_METHOD(""set_default_texels_per_unit"", ""texels""), &BakedLightmap::set_default_texels_per_unit);
	ClassDB::bind_method(D_METHOD(""get_default_texels_per_unit""), &BakedLightmap::get_default_texels_per_unit);

	ClassDB::bind_method(D_METHOD(""set_capture_propagation"", ""propagation""), &BakedLightmap::set_capture_propagation);
	ClassDB::bind_method(D_METHOD(""get_capture_propagation""), &BakedLightmap::get_capture_propagation);

	ClassDB::bind_method(D_METHOD(""set_capture_enabled"", ""enabled""), &BakedLightmap::set_capture_enabled);
	ClassDB::bind_method(D_METHOD(""get_capture_enabled""), &BakedLightmap::get_capture_enabled);

	ClassDB::bind_method(D_METHOD(""set_capture_cell_size"", ""capture_cell_size""), &BakedLightmap::set_capture_cell_size);
	ClassDB::bind_method(D_METHOD(""get_capture_cell_size""), &BakedLightmap::get_capture_cell_size);
#ifndef DISABLE_DEPRECATED
	ClassDB::bind_method(D_METHOD(""set_image_path"", ""image_path""), &BakedLightmap::set_image_path);
	ClassDB::bind_method(D_METHOD(""get_image_path""), &BakedLightmap::get_image_path);
#endif
	ClassDB::bind_method(D_METHOD(""bake"", ""from_node"", ""data_save_path""), &BakedLightmap::bake, DEFVAL(Variant()), DEFVAL(""""));

	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, ""extents""), ""set_extents"", ""get_extents"");

	ADD_GROUP(""Tweaks"", """");
	ADD_PROPERTY(PropertyInfo(Variant::INT, ""quality"", PROPERTY_HINT_ENUM, ""Low,Medium,High,Ultra""), ""set_bake_quality"", ""get_bake_quality"");
	ADD_PROPERTY(PropertyInfo(Variant::INT, ""bounces"", PROPERTY_HINT_RANGE, ""0,16,1""), ""set_bounces"", ""get_bounces"");
	ADD_PROPERTY(PropertyInfo(Variant::REAL, ""bounce_indirect_energy"", PROPERTY_HINT_RANGE, ""0,16,0.01""), ""set_bounce_indirect_energy"", ""get_bounce_indirect_energy"");
	ADD_PROPERTY(PropertyInfo(Variant::BOOL, ""use_denoiser""), ""set_use_denoiser"", ""is_using_denoiser"");
	ADD_PROPERTY(PropertyInfo(Variant::BOOL, ""use_hdr""), ""set_use_hdr"", ""is_using_hdr"");
	ADD_PROPERTY(PropertyInfo(Variant::BOOL, ""use_color""), ""set_use_color"", ""is_using_color"");
	ADD_PROPERTY(PropertyInfo(Variant::REAL, ""bias"", PROPERTY_HINT_RANGE, ""0.00001,0.1,0.00001,or_greater""), ""set_bias"", ""get_bias"");
	ADD_PROPERTY(PropertyInfo(Variant::REAL, ""default_texels_per_unit"", PROPERTY_HINT_RANGE, ""0.0,64.0,0.01,or_greater""), ""set_default_texels_per_unit"", ""get_default_texels_per_unit"");

	ADD_GROUP(""Atlas"", ""atlas_"");
	ADD_PROPERTY(PropertyInfo(Variant::BOOL, ""atlas_generate""), ""set_generate_atlas"", ""is_generate_atlas_enabled"");
	ADD_PROPERTY(PropertyInfo(Variant::INT, ""atlas_max_size""), ""set_max_atlas_size"", ""get_max_atlas_size"");

	ADD_GROUP(""Environment"", ""environment_"");
	ADD_PROPERTY(PropertyInfo(Variant::INT, ""environment_mode"", PROPERTY_HINT_ENUM, ""Disabled,Scene,Custom Sky,Custom Color""), ""set_environment_mode"", ""get_environment_mode"");
	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, ""environment_custom_sky"", PROPERTY_HINT_RESOURCE_TYPE, ""Sky""), ""set_environment_custom_sky"", ""get_environment_custom_sky"");
	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, ""environment_custom_sky_rotation_degrees"", PROPERTY_HINT_NONE), ""set_environment_custom_sky_rotation_degrees"", ""get_environment_custom_sky_rotation_degrees"");
	ADD_PROPERTY(PropertyInfo(Variant::COLOR, ""environment_custom_color"", PROPERTY_HINT_COLOR_NO_ALPHA), ""set_environment_custom_color"", ""get_environment_custom_color"");
	ADD_PROPERTY(PropertyInfo(Variant::REAL, ""environment_custom_energy"", PROPERTY_HINT_RANGE, ""0,64,0.01""), ""set_environment_custom_energy"", ""get_environment_custom_energy"");
	ADD_PROPERTY(PropertyInfo(Variant::COLOR, ""environment_min_light"", PROPERTY_HINT_COLOR_NO_ALPHA), ""set_environment_min_light"", ""get_environment_min_light"");

	ADD_GROUP(""Capture"", ""capture_"");
	ADD_PROPERTY(PropertyInfo(Variant::BOOL, ""capture_enabled""), ""set_capture_enabled"", ""get_capture_enabled"");
	ADD_PROPERTY(PropertyInfo(Variant::REAL, ""capture_cell_size"", PROPERTY_HINT_RANGE, ""0.25,2.0,0.05,or_greater""), ""set_capture_cell_size"", ""get_capture_cell_size"");
	ADD_PROPERTY(PropertyInfo(Variant::INT, ""capture_quality"", PROPERTY_HINT_ENUM, ""Low,Medium,High""), ""set_capture_quality"", ""get_capture_quality"");
	ADD_PROPERTY(PropertyInfo(Variant::REAL, ""capture_propagation"", PROPERTY_HINT_RANGE, ""0,1,0.01""), ""set_capture_propagation"", ""get_capture_propagation"");

	ADD_GROUP(""Data"", """");
#ifndef DISABLE_DEPRECATED
	ADD_PROPERTY(PropertyInfo(Variant::STRING, ""image_path"", PROPERTY_HINT_DIR, """", 0), ""set_image_path"", ""get_image_path"");
#endif
	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, ""light_data"", PROPERTY_HINT_RESOURCE_TYPE, ""BakedLightmapData""), ""set_light_data"", ""get_light_data"");

	BIND_ENUM_CONSTANT(BAKE_QUALITY_LOW);
	BIND_ENUM_CONSTANT(BAKE_QUALITY_MEDIUM);
	BIND_ENUM_CONSTANT(BAKE_QUALITY_HIGH);
	BIND_ENUM_CONSTANT(BAKE_QUALITY_ULTRA);

	BIND_ENUM_CONSTANT(BAKE_ERROR_OK);
	BIND_ENUM_CONSTANT(BAKE_ERROR_NO_SAVE_PATH);
	BIND_ENUM_CONSTANT(BAKE_ERROR_NO_MESHES);
	BIND_ENUM_CONSTANT(BAKE_ERROR_CANT_CREATE_IMAGE);
	BIND_ENUM_CONSTANT(BAKE_ERROR_LIGHTMAP_SIZE);
	BIND_ENUM_CONSTANT(BAKE_ERROR_INVALID_MESH);
	BIND_ENUM_CONSTANT(BAKE_ERROR_USER_ABORTED);
	BIND_ENUM_CONSTANT(BAKE_ERROR_NO_LIGHTMAPPER);
	BIND_ENUM_CONSTANT(BAKE_ERROR_NO_ROOT);

	BIND_ENUM_CONSTANT(ENVIRONMENT_MODE_DISABLED);
	BIND_ENUM_CONSTANT(ENVIRONMENT_MODE_SCENE);
	BIND_ENUM_CONSTANT(ENVIRONMENT_MODE_CUSTOM_SKY);
	BIND_ENUM_CONSTANT(ENVIRONMENT_MODE_CUSTOM_COLOR);
}

BakedLightmap::BakedLightmap() {
	extents = Vector3(10, 10, 10);

	default_texels_per_unit = 16.0f;
	bake_quality = BAKE_QUALITY_MEDIUM;
	capture_quality = BAKE_QUALITY_MEDIUM;
	capture_propagation = 1;
	capture_enabled = true;
	bounces = 3;
	bounce_indirect_energy = 1.0;
	image_path = """";
	set_disable_scale(true);
	capture_cell_size = 0.5;

	environment_mode = ENVIRONMENT_MODE_DISABLED;
	environment_custom_color = Color(0.2, 0.7, 1.0);
	environment_custom_energy = 1.0;
	environment_min_light = Color(0.0, 0.0, 0.0);

	use_denoiser = true;
	use_hdr = true;
	use_color = true;
	bias = 0.005;

	generate_atlas = true;
	max_atlas_size = 4096;
}
",16209,True,2780.654122828123,median
"[id=""ocp-4-2-release-notes""]
= {product-title} 4.2 release notes
include::modules/common-attributes.adoc[]
:context: release-notes

toc::[]

Red Hat {product-title} provides developers and IT organizations with a hybrid
cloud application platform for deploying both new and existing applications on
secure, scalable resources with minimal configuration and management overhead.
{product-title} supports a wide selection of programming languages and
frameworks, such as Java, JavaScript, Python, Ruby, and PHP.

Built on Red Hat Enterprise Linux and Kubernetes, {product-title}
provides a more secure and scalable multi-tenant operating system for today’s
enterprise-class applications, while delivering integrated application runtimes
and libraries. {product-title} enables organizations to meet security, privacy,
compliance, and governance requirements.

[id=""ocp-4-2-about-this-release""]
== About this release

Red Hat {product-title}
(link:https://access.redhat.com/errata/RHBA-2019:2921[RHBA-2019:2921]) is now
available. This release uses Kubernetes 1.14 with CRI-O runtime. New features,
changes, and known issues that pertain to {product-title} {product-version} are
included in this topic.

{product-title} {product-version} clusters are available at
https://cloud.openshift.com/openshift. The Red Hat OpenShift Cluster Manager
application for {product-title} allows you to deploy OpenShift clusters to
either on-premise or cloud environments.

{product-title} {product-version} is supported on Red Hat Enterprise Linux 7.6 and
later, as well as Red Hat Enterprise Linux CoreOS 4.1.

You must use {op-system-first} for the control plane, or master, machines and
can use either {op-system} or Red Hat Enterprise Linux 7.6 for compute, or worker,
machines.

[IMPORTANT]
====
Because only Red Hat Enterprise Linux version 7.6 is supported for compute
machines, you must not upgrade the Red Hat Enterprise Linux compute machines to
version 8.
====

[id=""ocp-4-2-new-features-and-enhancements""]
== New features and enhancements

This release adds improvements related to the following components and concepts.

[id=""ocp-4-2-installation-and-upgrade""]
=== Installation and upgrade

[id=""ocp-4-2-migrations""]
==== Migrations

Tooling and advice for moving from {product-title} 3.x to 4.x is now available.

[id=""ocp-4-2-openshift-install""]
==== CLI-based installation

{product-title} {product-version} introduces a new CLI-based installer called
`openshift-install`. It is designed to simplify provisioning OpenShift on
immutable installer provisioned infrastructure using an interactive guided
workflow within about 30 minutes. This approach provides an OpenShift deployment
with full stack automation of host OS and platform updates and infrastructure
management without the complexity of having to provision your own
infrastructure. Only minimal user input is needed with all non-essential
installation configuration options, which are now configured post-installation
via component operator Custom Resource Definitions (CRDs).

Updates are performed largely the same way. OpenShift update content must be
mirrored first to the local container registry first then the administrator
tells `oc adm upgrade` where to pull the update content from.

[id=""ocp-4-2-installations-in-restricted-networks""]
==== Installations in restricted networks

{product-title} {product-version} introduces support for installation and
updating {product-title} clusters in restricted network environments. It is
designed to work with any `docker` 2.2 spec-compliant container registry for
hosting {product-title} content.

Administrators first must replicate content from Quay.io to their local
container registry. After that is done, `openshift-install` can be configured to
generate Ignition configs that pull content locally rather than from Quay.io.
This is designed to work with user-provisioned infrastructure (UPI) deployments
only.

You can still use Operators from the OLM catalog in restricted networks.
However, you must manually pull the Operator sources in order to populate the
the offline catalog. This manual process is only a temporary workaround for
{product-title} {product-version}. An automated solution will be provided in a
future release.

See
xref:../installing/installing_restricted_networks/installing-restricted-networks-preparations.adoc#installing-restricted-networks-preparations[Installing in restricted networks]
and xref:../operators/olm-restricted-networks.adoc#olm-restricted-networks[Using Operator Lifecycle Manager on restricted networks]
for details.

[id=""ocp-4-2-cluster-wide-egresss-proxy""]
==== Cluster-wide egress proxy

{product-title} {product-version} introduces support for installing and updating
an {product-title} cluster through a corporate proxy server on user-provisioned infrastructure. Proxy information
(httpProxy, httpsProxy, and noProxy) can be defined in the `install-config.yaml` file, which
is used during the installation process and can also be managed
post-installation via the `cluster` Proxy object.

IMPORTANT: The cluster-wide proxy is only supported if you used a user-provisioned infrastructure installation for a supported provider.

Also, there is now support for providing your own CA bundles allowing the
corporate proxy to MITM HTTPS.

[id=""ocp-4-2-new-platform-boundary""]
==== New platform boundary

{product-title} is now aware of the entire infrastructure and brings the
operating system under management. This makes installation and updates seamless
across the platform and the underlying operating system. Everything is managed
as a single entity.

[id=""ocp-4-2-IPI-UPI""]
==== IPI and UPI

In {product-title} {product-version}, there are two primary installation
experiences: Full stack automation (IPI) and pre-existing infrastructure (UPI).

With full stack automation, the installer controls all areas of the installation
including infrastructure provisioning with an opinionated best practices
deployment of {product-title}. With pre-existing infrastructure deployments,
administrators are responsible for creating and managing their own
infrastructure allowing greater customization and operational flexibility.

[id=""ocp-4-2-full-stack-automated-deployments""]
==== Full stack automated deployments

In {product-title} {product-version}, there is expanded support for full stack
automated deployments to include AWS, Microsoft Azure, Google Cloud Platform (GCP),
and Red Hat OpenStack Platform, as well as adding GCP to the existing list of
user provisioned infrastructure supported providers that already includes AWS,
Bare Metal, and VMware vSphere.

[id=""ocp-4-2-operators""]
=== Operators

[id=""ocp-4-2-scoped-operator-installations""]
==== Scoped Operator installations

Previously, only users carrying `cluster-admin` roles  were allowed to install
Operators. In {product-title} 4.2, the `cluster-admin` can select namespaces in
which namespace administrators can install Operators self-sufficiently. The
`cluster-admin` defines the ServiceAccount in this namespace; all installed
Operators in this namespace get equal or lower permissions of this
ServiceAccount.

See
xref:../operators/olm-creating-policy.adoc#olm-creating-policy[Creating policy for Operator installations and upgrades]
for details.

[id=""ocp-4-2-ingress-operator""]
==== Ingress Operator
The Ingress Operator supports all ingress features on {product-version} with
installer-provisioned infrastructure on Azure and GCP.

[id=""ocp-4-2-machine-config-operator""]
==== Machine Config Operator

The Machine Config Operator (MCO) provides cluster-level configuration, enables
rolling upgrades, and prevents drift between new and existing nodes.

[id=""ocp-4-2-node-feature-discovery-operator""]
==== Node Feature Discovery Operator

The Node Feature Discovery (NFD) Operator detects hardware features available
on each node and advertises those features using node labels.

CPU features managed by NFD include:

* cpuid
* hardware_multithreading
* power
* pstate

Kernel features managed by NFD include:
* config
* selinux_enabled
* version
* os_version

Other features managed by NFD include:

* NVMe
* NUMA
* SR-IOV
* GPUs

The NFD Operator manages the installation and lifecycle of the NFD DaemonSet.
Access the NFD Operator in OperatorHub.

[id=""ocp-4-2-node-tuning-operator-enhancements""]
==== Node Tuning Operator enhancements

The Node Turning Operator was first introduced in {product-title} 4.1 and
manages cluster node-level tuning; The default CR is meant for delivering
standard node-level tuning. The enhancements in {product-title}
{product-version} allow for customizing the tunings for things such as high
performance.

For custom tuning, create your own tuned custom resources (CRs). Newly created
CRs will be combined with the default CR and custom tuning applied to nodes
based on node or pod labels and profile priorities.

[id=""ocp-4-2-storage""]
=== Storage

[id=""ocp-4-2-persistent-volumes-LSO""]
==== Persistent volumes using the Local Storage Operator

Persistent volumes using the Local Storage Operator is now available in
{product-title} {product-version}.

[id=""ocp-4-2-OCS""]
==== OpenShift Container Storage 4.2

With {product-title} {product-version}, OpenShift Container Storage (OCS) 4.2 is
available, providing persistent storage for applications and {product-title}
infrastructure services. OCS 4.2 will provide complete data services for
{product-title}, including dynamic provisioning of object buckets. This S3
capability is new in OCS 4.2. A consistent S3 interface is now added across
public and on-premise infrastructure.

[id=""ocp-4-2-CSI""]
==== OpenShift Container Storage Interface (CSI)

Container Storage Interface (CSI) is now available in {product-title}
{product-version}. CSI is introduced in Kubernetes to enable Red Hat OpenShift
Container Storage (OCS) and partners with their CSI plug-ins. With the adoption
of the CSI, the Kubernetes volume layer becomes truly
link:https://kubernetes.io/blog/2018/04/10/container-storage-interface-beta/[extensible].

For now, only the API is available. CSI drivers contained in operators will be
available in future releases.

[id=""ocp-4-2-storage-devices""]
==== Storage devices

The Cluster Storage Operator sets up the default storage class. It looks through
the cloud provider and sets up the correct storage class.

Raw Block with iSCSI is now in xref:ocp-4-2-technology-preview[Technology Preview].

New storage devices are supported in {product-title} {product-version}:

* Raw block with local Volumes
* Raw block with cloud providers (AWS, GCP, Azure, and vSphere)

[id=""ocp-4-2-scale""]
=== Scale

[id=""ocp-4-2-scale-cluster-limits""]
==== Cluster limits

Updated guidance around
xref:../scalability_and_performance/planning-your-environment-according-to-object-limits.adoc#planning-your-environment-according-to-object-limits[Cluster
Limits] for {product-title} {product-version} is now available.

Use the link:https://access.redhat.com/labs/ocplimitscalculator/[{product-title}
Limit Calculator] to estimate cluster limits for your environment.

[id=""ocp-4-2-developer-experience""]
=== Developer experience

[id=""ocp-4-2-ODO""]
==== OpenShift Do

OpenShift Do (ODO) is a CLI tool for developers to create, build, and deploy
applications on OpenShift. ODO is completely client based and requires no server
within the {product-title} cluster for deployment. It detects changes to local
code and deploys it to the cluster automatically, giving instant feedback to
validate changes in real time. It supports multiple languages and frameworks.

[id=""ocp-4-2-nodes""]
=== Nodes

[id=""ocp-4-2-crio-support""]
==== CRI-O support

CRI-O is a kubernetes-specific container engine that tracks and versions
identical to Kubernetes, simplifying support permutations. Adoption is trivial
because all existing Docker and OCI containers are supported and run well with
CRI-O.  CRI-O is a light weight, kubernetes-native, OCI-compatible container
runtime that is life-cycled and managed by {product-title}. You do not need to
worry about which container runtime is in use. With {product-title}, it is
always the right one and it provide a complete implementation of the Kubernetes
Container Runtime Interface (CRI). Also, you do not need to separately manage
the container engine. CRI-O has some tuneables that provide control and security
for CRI-O; they are easily configured in a CRD, and the settings are propagated
across the cluster.

[id=""ocp-4-2-whitelisting-of-sysctls""]
==== Whitelisting of sysctls configuration

System administrators can whitelist sysctl on a per-node basis. All safe sysctls
are enabled by default; all unsafe sysctls are disabled by default. See
xref:../nodes/containers/nodes-containers-sysctls.adoc#nodes-containers-sysctls[Using
sysctls in containers] for more information.

[id=""ocp-4-2-master-nodes-schedulable""]
==== Master nodes are now schedulable

In {product-title} {product-version}, master nodes are schedulable. See
xref:../nodes/nodes/nodes-nodes-working.adoc[Working with nodes] for more
information.

[id=""ocp-4-2-networking""]
=== Networking

==== Installer-provisioned OpenShift on OpenStack

{product-title} {product-version} introduces full-stack automation support for
deploying {product-title} clusters on Red Hat OpenStack.

The installer uses the OpenStack APIs in conjunction with the Kubernetes
OpenStack Cloud Provider to create all the required OpenStack resources, such as
virtual machines (VMs), networks, security groups, and object storage needed to
deploy {product-title} and properly configure the cluster to run on the Red Hat
OpenStack Platform.

{product-title} {product-version} can be deployed on Red Hat OpenStack version
13.

Kuryr exists to improve the network performance of pods when running workloads
on Red Hat OpenStack. Kuryr is an SDN solution combining a Kubernetes CNI plug-in
(kuryr-kubernetes) and OpenStack Neutron to provide interconnectivity between
Kubernetes pods and OpenStack virtual instances.

[id=""ocp-4-2-OVN""]
==== OVN (Technology Preview)

Open Virtual Networking (OVN) for Open vSwitch, currently in
xref:ocp-4-2-technology-preview[Technology Preview], has many advantages,
including acceleration of customer-driven feature requirements, some of which
are pre-enabled, including:

* Low barrier to integration; an implementation of virtual networking via OVS.
* SDN portfolio consolidation.
* Virtually eliminate iptables scale issues.
* Heterogeneous Linux/Windows clusters.
* The ability to have a cluster network that spans on-premise nodes and cloud
nodes.
* Full Network Policy support.
* Egress IP per pod.
* Distributed L4 Ingress/Egress firewall.
* Distributed services load balancer.
* Heterogeneous clusters with Windows nodes
* The capability to span on-premise and cloud nodes.
* Traffic isolation and multi-tenancy.
* Data Plane Development Kit (DPDK) support.
* Encrypted tunnels.
* IPv6 and DHCPv6.
* QoS, control and data plane separation.

[id=""ocp-4-2-enable-ingress-controllers""]
==== Enable internal Ingress Controllers for private clusters

When creating an Ingress Controller on cloud platforms, the Ingress Controller is
published by a public cloud load balancer by default.

Users can now publish Ingress Controllers with internal cloud load balancers. For
example:

[source,yaml]
----
apiVersion: operator.openshift.io/v1
kind: IngressController
metadata:
  namespace: openshift-ingress-operator
  name: internal
spec:
  endpointPublishingStrategy:
    type: LoadBalancerService
    loadBalancer:
      scope: Internal
----

See the
link:https://kubernetes.io/docs/concepts/services-networking/#internal-load-balancer.[Kubernetes
Services documentation] for implementation details.

Once set, `.spec.endpointPublishingStrategy.loadBalancer.scope` cannot
be changed. To change the scope, delete and recreate the Ingress Controller.

The `default` Ingress Controller can be made internal by deleting and recreating
it.

See xref:../networking/ingress-operator.adoc#configuring-ingress[Ingress
Operator in {product-title}] for more information.

[id=""ocp-4-2-kubernetes-cni-plug-in-additions""]
==== Kubernetes CNI plug-in additions and enhancements

Several Kubernetes CNI plug-ins are added or enhanced in {product-title}
{product-version} to grow capability.

These SR-IOV solutions remain in Technology Preview in {product-title}
{product-version}:

* RDMA and RoCE Support
* DPDK Mode for SR-IOV VFs
* Admission Controller
* Operator

New CNI plug-ins:

* IPVLAN
* Bridge with VLAN
* Static IPAM

[id=""ocp-4-2-enablement-of-GPUs""]
==== Enablement of GPUs in an OpenShift cluster

GPUs are now supported on Red Hat Enterprise Linux (RHEL) 7 nodes. They are not
supported on RHEL CoreOS nodes because of lack of support for CUDA driver and
driver containers.

[id=""ocp-4-2-web-console""]
=== Web console

[id=""ocp-4-2-custom-branding""]
==== Console customization options

You can customize the {product-title} web console to set a custom logo, links,
notification banners, and command line downloads. This is especially helpful if you
need to tailor the web console to meet specific corporate or government
requirements.

See Customizing the web console for more information.

[id=""ocp-4-2-new-api-explorer""]
==== New API Explorer

You can now easily search and manage API resources in the *Explore API
Resources* dashboard located at *Home* -> *Explore*.

View the schema for each API and what parameters being supported, manage the
instances of the API, and review the access of each API.

[id=""ocp-4-2-machine-autoscaler""]
==== Machine Autoscaler

You can now scale your cluster with the Machine Autoscaler. The Machine
Autoscaler adjusts the number of Machines in the MachineSets being deployed in
your cluster. Increase Machines when the cluster runs out of resources to
support more deployments.  Any changes, such as the minimum or maximum number of
instances, are immediately applied to the MachineSet that MachineAutoscalers
target.

[id=""ocp-4-2-developer-perspective""]
==== Developer Perspective

The Developer perspective adds a developer-focused perspective to the web
console. It provides workflows specific to developer use cases, such as creation
and deployment of applications to {product-title} using multiple options. It
provides a visual representation of the applications within a project, their
build status, and the components and services associated with them,  enabling
easy interaction and monitoring. It incorporates Serverless capabilities
(Technology Preview) and the ability to create workspaces to edit your
application code using Eclipse Che.

[id=""ocp-4-2-prometheus-queries""]
==== Prometheus queries

You can now run Prometheus queries directly in the web console. Navigate to
*Monitoring* -> *Metrics*.

[id=""ocp-4-2-web-console-idps""]
==== Identity providers

On the cluster OAuth configuration page, more identity providers (IDPs) are
provided for the user to log in to the cluster. The IDPs include GitHub, GitLab,
Google, LDAP, Keystone, and so on.

[id=""ocp-4-2-general-web-console-updates""]
==== General web console updates

* The dashboard is redesigned with more metrics.
* *Catalog* is moved to the *Developer* perspective: *Developer* -> *Add+* -> *From
Catalog*.
* Status of projects is now moved to the *Workloads* tab on the project details page.
* OperatorHub is now located under the *Operators* menu.
* There is now support for chargeback. You can break down the reserved and used
resources requested by applications.
* There is now support for native templates without needing to enable the Service
Catalog, which is now deprecated.

[id=""ocp-4-2-notable-technical-changes""]
== Notable technical changes

{product-title} {product-version} introduces the following notable technical
changes.

[discrete]
[id=""ocp-4-2-corsAllowedOrigins""]
==== corsAllowedOrigins

`corsAllowedOrigins` can now be configured. See
xref:../authentication/allowing-javascript-access-api-server.adoc[Allowing
JavaScript-based access to the API server from additional hosts] for more
information.

[discrete]
[id=""ocp-4-2-new-cni-plugins""]
==== New CNI plug-ins

There are two new CNI plug-ins for Multus: bridge and ipvlan.

[discrete]
[id=""ocp-4-2-cno-supports-SimpleMacvlan""]
==== CNO supports SimpleMacvlan

CNO now supports configuring SimpleMacvlan.

[discrete]
[id=""ocp-4-2-layers""]
==== Builds maintain their layers

In {product-title} {product-version}, builds keep their layers by default.

[discrete]
[id=""ocp-4-2-windows-builds-not-supported""]
==== Builds on Windows

Builds are not scheduled on Windows nodes.

[discrete]
[id=""ocp-4-2-ingress-controller-support-disabled""]
==== Ingress controller support disabled

Ingress controller TLS 1.0 and 1.1 support is now disabled to match the
Mozilla intermediate security profile.

New and upgraded ingress controllers will no longer support these TLS versions.

[discrete]
[id=""ocp-4-2-remove-csc-usage""]
==== Reduce OperatorHub complexity by removing CatalogSourceConfig usage

OperatorHub has been updated to reduce the
number of API resources a cluster administrator must interact with and
streamline the installation of new Operators on {product-title} 4.2.

To work with OperatorHub in {product-title} 4.1, cluster administrators
primarily interacted with OperatorSource and CatalogSourceConfig API resources.
OperatorSources are used to add external datastores where Operator bundles are
stored.

CatalogSourceConfigs were used to enable an Operator present in the
OperatorSource of your cluster. Behind the scenes, it configured an Operator
Lifecycle Manager (OLM) CatalogSource so that the Operator could then be managed
by OLM.

To reduce complexity, OperatorHub in {product-title} 4.2 no longer uses
CatalogSourceConfigs in the workflow of installing Operators. Instead,
CatalogSources are still created as a result of adding OperatorSources to the
cluster, however Subscription resources are now created directly using the
CatalogSource.

[discrete]
[id=""ocp-4-2-global-catalog-namespace""]
==== Global catalog namespace change

In {product-title} 4.1, the default global catalog namespace, where
CatalogSources are installed by default, is
`openshift-operator-lifecycle-manager`. Starting with {product-title} 4.2, this
has changed to the `openshift-marketplace` namespace.

If you have installed an Operator from OperatorHub on a {product-title} 4.1
cluster, the CatalogSource is in the same namespace as the Subscription. These
Subscriptions are not affected by this change and should continue to behave
normally after a cluster upgrade.

In {product-title} 4.2, if you install an Operator from OperatorHub, the
Subscription created refers to a CatalogSource located in the new global
catalog namespace `openshift-marketplace`.

[discrete]
[id=""ocp-4-2-global-catalog-namespace-workaround""]
===== Workaround for existing Subscriptions in the previous global catalog namespace

If you have existing CatalogSources in the old
`openshift-operator-lifecycle-manager` namespace, any existing Subscription
objects that are referring to the CatalogSource will fail to upgrade, and new
Subscription objects that are referring to the CatalogSource will fail to
install.

To workaround such upgrade failures:

.Procedure
. Move the CatalogSource object from the previous global catalog namespace to
the `openshift-marketplace` namespace.

[id=""ocp-41-deprecated-features""]
=== Deprecated features

[discrete]
[id=""ocp-4-2-deprecation-of-service-catalog""]
==== Deprecation of the Service Catalog, the Template Service Broker, the Ansible Service Broker, and their Operators

In {product-title} {product-version}, the Service Catalog, the Template Service
Broker, the Ansible Service Broker, and their Operators are deprecated. They
will be removed in a future {product-title} release.

The following related APIs will be removed in a future release:

* `*.servicecatalog.k8s.io/v1beta1`
* `*.automationbroker.io/v1alpha1`
* `*.osb.openshift.io/v1`

[discrete]
[id=""ocp-4-2-deprecation-of-cluster-role-apis""]
==== Deprecation of cluster role APIs

The following APIs are deprecated and will be removed in a future release:

* `ClusterRole.authorization.openshift.io` - Use `ClusterRole.rbac.authorization.k8s.io` instead.
* `ClusterRoleBinding.authorization.openshift.io` - Use `ClusterRoleBinding.rbac.authorization.k8s.io` instead.
* `Role.authorization.openshift.io` - Use `Role.rbac.authorization.k8s.io` instead.
* `RoleBinding.authorization.openshift.io` - Use `RoleBinding.rbac.authorization.k8s.io` instead.

[discrete]
[id=""ocp-4-2-deprecation-of-operatorsources""]
==== Deprecation of OperatorSources

In a future release, OperatorSources will be deprecated from OperatorHub and the
`operatorsource.operators.coreos.com/v1` API will be removed.

[discrete]
[id=""ocp-4-2-deprecation-of-oapi-endpoint""]
==== Deprecation of `/oapi` endpoint from `oc`

The usage of the `/oapi` endpoint from `oc` is being deprecated and will be
removed in a future release. The `/oapi` endpoint was responsible for serving
non-group {product-title} APIs and was removed in 4.1.

[discrete]
[id=""ocp-4-2-deprecation-of-short-flag""]
==== Deprecation of the `-short` flag of `oc version`

The `oc version --short` flag is now deprecated. The `--short` flag printed
default output.

[discrete]
[id=""ocp-4-2-oc-adm-migrate-commands-deprecated""]
==== `oc adm migrate` commands

The `oc adm migrate` command and all of its subcommands except for `oc adm
migrate template-instances` are now deprecated.

[discrete]
[id=""ocp-4-2-PV-snapshots-deprecated""]
==== Persistent volume snapshots

In the {product-title} 4.1 Release Notes, persistent volume snapshot was
incorrectly marked as Technology Preview. This functionality was deprecated in
{product-title} 3.11.

[discrete]
[id=""ocp-4-2-EFS""]
==== EFS

In the {product-title} 4.1 Release Notes, EFS was incorrectly marked as
generally available. This is being included as a Technology Preview feature in
{product-title} {product-version}.

[discrete]
[id=""ocp-4-2-recycle-reclaim-policy""]
==== Recycle reclaim policy

Recycle reclaim policy is now deprecated. Dynamic provisioning is recommended.

[id=""ocp-4-2-bug-fixes""]
== Bug fixes

*Builds*

* Blocked registries were not set in `registries.conf` used by Buildah. Therefore,
Buildah could push an image to a registry blocked by the cluster image policy.
With this bug fix, the `registries.conf` file generated for builds now includes
blocked registries. Builds now respect the blocked registries setting for image
pull and push.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1730722[*BZ#1730722*])

* When shell variables were referenced in build configurations that used the
source-to-image build strategy, logic that attempted to produce a Dockerfile,
which could be used to perform the source-to-image build, would incorrectly
attempt to evaluate those variables. As a result, some shell variables would be
erroneously evaluated as empty values, leading to build errors, and other
variables would trigger error messages from failed attempts to evaluate them.
Shell variables referenced in build configurations are now properly escaped, so
that they are evaluated at the expected time. These errors should no longer be
observed.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1712245[*BZ#1712245*])

* Due to a logic bug, attempts to push an image to a registry after it was built
would fail if the build's BuildConfig specified an output of type DockerImage,
but the name that was specified for that output image did not include a tag
component. The attempt to push a built image would fail. The builder now adds
the ""latest"" tag to a name if one is not specified. An image built using a
BuildConfig specifying an output of type DockerImage, with a name that does not
include a tag component, will now be pushed using the ""latest"" tag.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1746499[*BZ#1746499*])

* Previously, there was a memory limit on the Pod. As a result, the Credential
Operator could crash on clusters with large numbers of projects/namespaces. With
this bug fix, the memory limit is removed, the Operator no longer crashes, and
memory is handled by the cluster itself.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1711402[*BZ#1711402*])

*Image Registry*

* TLS keys were not added to registry routes. This is because TLS keys were stored
in `Secret.StringData` and the Operator was unable to see the real data in the
secret. Now, Secret.Data is used instead and the Operator can see the values.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1719965[*BZ#1719965*])

* The drain process would take up to 600 seconds to evict the image-registry pod.
This was because the image registry was running from sh and signals were not
propagated to the image registry, and unable to receive SIGTERM. Now, the
registry process uses exec and the registry is the pid 1 process and able to
receive SIGTERM. Drain now evicts successfully.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1729979[*BZ#1729979*])

* `must-gather` did not collect PVCs and events in the `openshift-image-registry`
 namespace. Now, PVCs are collected as part of the `must-gather` process.
 (link:https://bugzilla.redhat.com/show_bug.cgi?id=1737558[*BZ#1737558*])

*Installer*

* Default minimal installations of Red Hat Enterprise Linux would install and
enable firewalld.service. The firewall service would block ports that prevented
`oc rsh/exec/logs` from working as expected. Now, `firewalld.service` is disabled
if it is installed to conform to testing standards.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1740439[*BZ#1740439*])

* Workers were not created when the default path for images was changed from the
 default settings. Now, the installer creates and uses it's own storage pool.
 (link:https://bugzilla.redhat.com/show_bug.cgi?id=1707479[*BZ#1707479*])

*kube-apiserver*

* It was possible to shorten certificate rotation by creating a ConfigMap. This
behavior is not supported. Now, if you create this ConfigMap, `Upgradable` is
set to `False` on the kubeapiserver-operator, which means that you can no longer
update your cluster.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1722550[*BZ#1722550*])

*Logging*

* The dynamic seeding function of Elasticsearch was inefficient, and clusters with
a large number of projects made too many calls. This issue was compounded by a
lack of caching. Because of the inefficient seeding and lack of caching, calls
to Elasticsearch were timing out before a response was returned. This bug fix
added API call caching and ACL seeding. These improvements reduce the
opportunity for page timeouts.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1705589[*BZ#1705589*])

* The Logging Operator relied on the type of information stream to set the log
type, so logs sent to `stdout` were tagged as `INFO` and logs sent to `stderr`
were tagged as `ERROR`. This method does not always correctly convey the
information type. Now, the log level is no longer set based on the information
stream. Instead, it is set to `unknown` if the correct log level cannot be
determined.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1726639[*BZ#1726639*])

* During Cluster Logging instance deletion, resources under Cluster Logging were
deleted independently. Therefore, there could be a short time period when the
Fluentd or Rsyslog DaemonSet was still running but its log collector service
account was removed. This made the logs processed in this time miss Kubernetes
information, including the namespace name. With this bug fix, the service
accounts now wait to be deleted until all descendant resources are deleted.
There is now no chance for the collector DaemonSets to run without the log
collector service account.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1715370[*BZ#1715370*])

*Web Console*

* Previously, console Operator logs for events would print some duplicate
messages. A version update for a dependency repository has resolved this issue
and messages are no longer being duplicated in console Operator logs.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1687666[*BZ#1687666*])

* Users were not able to copy the whole webhook URL since the secret value was
obfuscated. A link was added so that users are now able to copy the entire
webhook URL with the secret value included.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1665010[*BZ#1665010*])

* The Machine and Machine Set details pages in the web console did not contain an
*Events* tab. An *Events* tab is now added and is now available from the *Machine*
and *Machine Set* details pages.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1693180[*BZ#1693180*])

* Previously, users could not view a node's status from its details page in the
web console. A status field has been added and users can now view a node's
status from its details page.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1706868[*BZ#1706868*])

* Previously, you would occasionally see a blank popup in the web console if you
attempted to create an Operator resource immediately after installing an
Operator through the OperatorHub. With this bug fix, a clear message is now
shown if you attempt to create a resource before it is available.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1710079[*BZ#1710079*])

* Previously the Deployment Config Details page in the web console would say that
the status was *Active* before the first revision had rolled out. With this bug
fix, the status now says *Updating* before a rollout has occurred, and *Up to
date* when the rollout is complete.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1714897[*BZ#1714897*])

* Previously, the metrics charts for nodes in the web console could incorrectly
total usage for more than one node in some circumstances. With this bug fix, the
node page charts now correctly display the usage only for that node.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1720119[*BZ#1720119*])

* Previously, the ca.crt value for OpenID identity providers was not set properly
when created through the web console. The problem has been fixed, and the ca.crt
is now correctly set.
link:https://bugzilla.redhat.com/show_bug.cgi?id=1727282[*BZ#1727282*])

* Previously, users would see an error in the web console when navigating to the
ClusterResourceQuota instances from the CRD list. The problem has been fixed,
and you can now successfully list ClusterResourceQuota instances from the CRD
page. (link:https://bugzilla.redhat.com/show_bug.cgi?id=1742952[*BZ#1742952*])

* Previously, the web console did not show when a node was unscheduleable in the
node list. This was inconsistent with the CLI. The console now shows when a node
is unscheduleable from the node list and node details pages.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1748405[*BZ#1748405*])

* Previously, the web console would show config map and secret keys with all caps
styling in the resource details pages. This is a problem as key names are often
file names and case sensitive. The {product-title} {product-version} web console
now shows config map and secret keys in their proper case.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1752572[*BZ#1752572*])

*Networking*

* Egress IP addressess did not work correctly in namespaces with restrictive
NetworkPolicies. As a result, Pods that accepted traffic from specific sources
would not be able to send egress traffic through egress IPs, because the
response from the external server would be mistakenly rejected by their
NetworkPolicies. With this bug fix, replies from egress traffic are now
correctly recognized as replies rather than as new connections. Egress IPs and
NetworkPolicy work together.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1700431[*BZ#1700431*])

* If a pod using an external IP address to contact an external host received an
external IP address not responding condition, the egress IP monitoring code
mistakenly determined that the host was not responding. As a result,
highly-available egress IPs could get switched to a different node to another.
The monitoring code was fixed to distinguish between a egress node not
responding and a final destination not responding conditions. Highly available
egress IPs are not be switched between nodes unnecessarily.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1717639[*BZ#1717639*])

* By default, the etcd namespace was created without specifying a net id. As a
result, API server components could not connect to etcd. The code was fixed to
specify `netid=1` for the etcd namespace.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1719653[*BZ#1719653*])

*Node*

* The algorithm used when merging additional IP addresses added to a node was
incorrect. As a result, when adding an additional IP address to a node, the list
of addresses was out of order, resulting in the node being unable to communicate
to the API server. The merge algorithm for addresses was changed to not reorder
the addresses. Adding secondary IP addresses to a node no longer changes the
ordering and the node is able to continue communication with the API server.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1696628[*BZ#1696628*])

* Because of a problem with the kubeConfig controller, changes to the kubelet
Config are reverted if the cluster is upgraded to a version that uses a
different OS release. The code was fixed to specify the correct controller in
the source. Customizations to the kubeletConfig will be retained.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1718726[*BZ#1718726*])

*oc*

* The wrong validation for node selector labels was causing empty values for keys
on labels to not be accepted. This update fixes the node selector label
validation mechanism so that an empty value for a key on label is a valid node
selector.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1683819[*BZ#*1683819*])

* The `oc get` command was not returning the proper information when it received
an empty result list. This update improves the information that is returned when
`oc get` receives an empty list.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1708280[*BZ#1708280*])

*OLM*

* Marketplace Cluster Operator was reporting `degraded` when restarting or
upgrading the Marketplace Operator. Therefore, the {product-title} upgrade tests
were failing. With this bug fix, the upgrade tests are passing again because
{product-title} is no longer reporting `degraded` when the Operator is stopped.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1706867[*BZ#1706867*])

* A bug during upgrade was causing Marketplace Operator to degrade and exit. The
ClusterOperator status did not give an accurate description of the health of the
Marketplace Operator.
+
The following issues were contributing to this:
+
** Multiple Marketplace Operators were running and updating the ClusterOperatorStatus at the same time.
** The sync would fail if an error occurred while reconciling an operand (OperatorSources or CatalogSourceConfigs). This allowed network issues or invalid operands to drive to a degraded state. The Marketplace Operator also degraded when failed syncs surpassed a threshold of total syncs.
** It was difficult to identify why a ClusterOperatorStatus condition was in a given state via telemetry. Marketplace did not set a reason, although telemetry includes the state and reason.
+
With this bug fix:
+
** Leader election provided by the Operator SDK prevents multiple Marketplace Operators from updating the ClusterOperatorStatus at the same time.
** Marketplace only reports a degraded state when it is unable to get or update its operands, rather than whenever an error is encountered while reconciling an operand.
** Marketplace now includes a reason when setting a condition so that telemetry provides better insights into the state of the Marketplace Operator.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1721537[*BZ#1721537*])

* The CatalogSourceConfig (csc) and OperatorSource (opsrc) Custom Resource
Definitions (CRDs) owned by Marketplace did not include a description.
Therefore, `oc explain csc` and `oc explain opsrc` would return empty
descriptions. With this bug fix, OpenAPI CRD definitions are now added so that
`oc explain csc` and `oc explain opsrc` now work.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1723835[*BZ#1723835*])

* The Marketplace Operator was overwriting the Pod deployment spec of registry
deployments associated with OperatorSources. Therefore, users were unable to add
NodeSelectors. With this bug fix, required fields are only replaced in the
deployment spec on OperatorSource updates, allowing users to add NodeSelectors
to the Operator registry Pod associated with OperatorSources. By default, no
NodeSelector is present. Users can now add NodeSelectors to the Pod spec in the
registry Pod deployments. For example, with the `community-operators`
OperatorSource, you would edit the `community-operators` deployment in the
`openshift-marketplace` namespace.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1696726[*BZ#1696726*])

* The Marketplace Operator was scaling the registry deployment down and then scaling
it back up to force updates. This could cause the Pod to crash-loop if there was
an issue in the registry Pod. This bug fix uses annotation to force the update,
rather than scaling the registry deployment up and down so that the deployment
will not become unavailable. Note that this alone will not fix the bug. A fix is
required to the end-to-end test that does not fail it on crash-looping Pods in
the 'openshift-marketplace’ namespace.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1700100[*BZ#1700100*])

* The must-gather tool requires a field, `RelatedObjects`, in the ClusterOperator
Custom Resource to be populated with ObjectReferences of the resources
associated with the Operator. Because this field was missing for Marketplace,
the must-gather tool was not able to gather enough information about the
Marketplace Operator. This update now populates the `RelatedObjects` field with
the Operator’s namespace and the
OperatorSource/CatalogSourceConfig/CatalogSource resources. This enables the
must-gather tool to gather enough information about the Marketplace Operator.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1717439[*BZ#1717439*])

*OpenShift Controller Manager*

* Setting the OpenShift Controller Manager Operator to `Unmanaged` or `Removed` is
unsupported, so it would cause the conditions on the corresponding
ClusterOperator object to go to an `Unknown` status. With this bug fix, the
OpenShift Controller Manager Operator now ignores the unsupported `Unmanaged’
and `Removed` settings for management state. A message now explains this in the
ClusterOperator status conditions.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1719188[*BZ#1719188*])

*Red Hat Enterprise Linux CoreOS (RHCOS)*

* Previously, SSH connections were hanging when the ClientAliveInterval within the
sshd configuration was not set to 180 as required by Microsoft Azure. This bug
fix now defaults the sshd config to 180 so that SSH no longer hangs within
Azure. (link:https://bugzilla.redhat.com/show_bug.cgi?id=1701050[*BZ#1701050*])

*Routing*

* Previously, the Automation Broker always created a network policy to give a
transient namespace access to the target namespace. As a consequence, the target
namespace locked down to the newly created policy and namespaces could
communicate with each other. This fix causes the Automation Broker to check if
there are network policies in place for the target namespace, and if there are
none, to not create a new network policy. This fix allows the Automation Broker
to perform Ansible Playbook Bundle actions actions without affecting the
existing services running in the target namespace.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1643303[*BZ#1643303*])

* Previously, the OpenShift Ansible Service Broker Operator did not pass metrics to
Prometheus unless the correct permissions were manually applied. With this
update, the Operator now automatically installs with the required permissions.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1692281[*BZ#1692281*])

*Templates*

* Previously, the custom resource definition for the Samples Operator
configuration object (`configs.samples.operator.openshift.io`) did not have
openAPIV3Schema validation defined. Therefore,`oc explain` was unable to provide
useful information about the object. With this fix, openAPIV3Schema validation
was added, and now `oc explain` works on the object.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1705753[*BZ#1705753*])

* Previously, the Samples Operator was using a direct {product-title] go client to
make GET calls in order to maintain controller/informer based watches for
secrets, imagestreams, and templates. This resulted in unnecessary API calls
were being made against the {product-title} API server. This fix leverages the
informer/listener API and reduces activity against the {product-title} API
server. (link:https://bugzilla.redhat.com/show_bug.cgi?id=1707834[*BZ#1707834*])

* Previously, the Samples Operator was not creating a cluster role that aggregated
into the cluster-reader role. As a consequence, users with the cluster-reader
role could not read the config object for the samples Operator. With this
update, the manifest of the samples operator was updated to include a cluster
role for read-only access to its config object, and this role aggregated into
the cluster-reader role. Now, users with the cluster-reader role can read, list,
and watch the config object for the samples Operator.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1717124[*BZ#1717124*])

[id=""ocp-4-2-technology-preview""]
== Technology Preview features

Some features in this release are currently in Technology Preview. These
experimental features are not intended for production use. Note the
following scope of support on the Red Hat Customer Portal for these features:

link:https://access.redhat.com/support/offerings/techpreview[Technology Preview
Features Support Scope]

In the table below, features marked *TP* indicate _Technology Preview_ and
features marked *GA* indicate _General Availability_. Features marked as *-*
indicate that the feature is removed from the release or deprecated.

.Technology Preview Tracker
[cols=""4"",options=""header""]
|====
|Feature |OCP 3.11 |OCP 4.1 |OCP 4.2

|Prometheus Cluster Monitoring
|GA
|GA
|GA

|Local Storage Persistent Volumes
|TP
|TP
|TP

|CRI-O for runtime pods
|GA* footnoteref:[disclaimer, Features marked with `*` indicate delivery in a z-stream patch.]
|GA
|GA

|Tenant Driven Snapshotting
|TP
|TP
|TP

|`oc` CLI Plug-ins
|TP
|TP
|TP

|Service Catalog
|GA
|GA
|--

|Template Service Broker
|GA
|GA
|--

|OpenShift Ansible Service Broker
|GA
|GA
|--

|Network Policy
|GA
|GA
|GA

|Multus
|-
|GA
|GA

|New Add Project Flow
|GA
|GA
|GA

|Search Catalog
|GA
|GA
|GA

|Cron Jobs
|GA
|GA
|GA

|Kubernetes Deployments
|GA
|GA
|GA

|StatefulSets
|GA
|GA
|GA

|Explicit Quota
|GA
|GA
|GA

|Mount Options
|GA
|GA
|GA

|System Containers for Docker, CRI-O
|-
|-
|-

|Hawkular Agent
|-
|-
|-

|Pod PreSets
|-
|-
|-

|experimental-qos-reserved
|TP
|TP
|TP

|Pod sysctls
|GA
|GA
|GA. See xref:ocp-4-2-known-issues[Known issues] for current limitations.

|Central Audit
|GA
|-
|-

|Static IPs for External Project Traffic
|GA
|GA
|GA

|Template Completion Detection
|GA
|GA
|GA

|`replicaSet`
|GA
|GA
|GA

|Fluentd Mux
|TP
|TP
|TP

|Clustered MongoDB Template
|-
|-
|-

|Clustered MySQL Template
|-
|-
|-

|ImageStreams with Kubernetes Resources
|GA
|GA
|GA

|Device Manager
|GA
|GA
|GA

|Persistent Volume Resize
|GA
|GA
|GA

|Huge Pages
|GA
|GA
|GA

|CPU Pinning
|GA
|GA
|GA

|Admission Webhooks
|TP
|GA
|GA

|External provisioner for AWS EFS
|TP
|TP
|TP

|Pod Unidler
|TP
|TP
|TP

|Node Problem Detector
|TP
|TP
|TP

|Ephemeral Storage Limit/Requests
|TP
|TP
|TP

|Descheduler
|TP
|TP
|TP

|CephFS
|TP
|TP
|TP

|Podman
|TP
|TP
|TP

|Kuryr CNI Plug-in
|TP
|TP
|TP

|Sharing Control of the PID Namespace
|TP
|TP
|TP

|Manila Provisioner
|TP
|TP
|TP

|Cluster Administrator console
|GA
|GA
|GA

|Cluster Autoscaling (AWS Only)
|GA
|GA
|GA

|Container Storage Interface (CSI)
|TP
|TP
|GA

|Operator Lifecycle Manager
|TP
|GA
|GA

|Red Hat OpenShift Service Mesh
|TP
|TP
|TP

|""Fully Automatic"" Egress IPs
|GA
|GA
|GA

|Pod Priority and Preemption
|GA
|GA
|GA

|Multi-stage builds in Dockerfiles
|TP
|GA
|GA

|OVN
|
|TP
|TP

|OVN SDN
|
|TP
|TP

|HPA custom metrics adapter based on Prometheus
|
|TP
|TP

|Machine health checks
|
|TP
|TP

|Raw Block with iSCSI
|
|
|TP

|OperatorHub
|
|
|GA
|====

[id=""ocp-4-2-known-issues""]
== Known issues

* Unsafe sysctl cannot be used in {product-title} {product-version}.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1690754[*BZ#1690754*])

* `git clone` operations that go through an HTTPS proxy will fail. Non-TLS (HTTP)
proxies can be used successfully.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1750650[*BZ#1750650*])

* Builds that use image references that correlate to an image mirror, which is
the case in a disconnected environment, will fail to pull or push those image
references if the mirror requires authentication.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1745192[*BZ#1745192*])

* Image stream import does not use mirrors. This is often used in disconnected environments.
(link:https://bugzilla.redhat.com/show_bug.cgi?id=1741391[*BZ#1741391*])

* `git clone` via SSH does not work through a proxy.

* If builds use a build secret, it is strongly recommended that layers are squashed
using `imageOptimizationPolicy: SkipLayers`. Otherwise, secrets might leak in
`source` and `docker` strategy builds.
",12294,False,2081.962644470384,median
"[[netty-component]]
= Netty Component
:docTitle: Netty
:artifactId: camel-netty
:description: Socket level networking using TCP or UDP with the Netty 4.x.
:since: 2.14
:supportLevel: Stable
:component-header: Both producer and consumer are supported
include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/netty.adoc[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[]
",12430,False,2347.6749327720136,median
"= Stream Decorator Reference
:page-tocclass: right
:page-toclevels: 1
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// ""License""); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// ""AS IS"" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

== cartesianProduct

The `cartesianProduct` function turns a single tuple with a multi-valued field (i.e., an array) into multiple tuples, one for each value in the array field. That is, given a single tuple containing an array of N values for fieldA, the `cartesianProduct` function will output N tuples, each with one value from the original tuple's array. In essence, you can flatten arrays for further processing.

For example, using `cartesianProduct` you can turn this tuple
[source,text]
----
{
  ""fieldA"": ""foo"",
  ""fieldB"": [""bar"",""baz"",""bat""]
}
----

into the following 3 tuples
[source,text]
----
{
  ""fieldA"": ""foo"",
  ""fieldB"": ""bar""
}
{
  ""fieldA"": ""foo"",
  ""fieldB"": ""baz""
}
{
  ""fieldA"": ""foo"",
  ""fieldB"": ""bat""
}
----

=== cartesianProduct Parameters

* `incoming stream`: (Mandatory) A single incoming stream.
* `fieldName or evaluator`: (Mandatory) Name of field to flatten values for, or evaluator whose result should be flattened.
* `productSort='fieldName ASC|DESC'`: (Optional) Sort order of the newly generated tuples.

=== cartesianProduct Syntax

[source,text]
----
cartesianProduct(
  <stream>,
  <fieldName | evaluator> [as newFieldName],
  productSort='fieldName ASC|DESC'
)
----

=== cartesianProduct Examples

The following examples show different outputs for this source tuple

[source,text]
----
{
  ""fieldA"": ""valueA"",
  ""fieldB"": [""valueB1"",""valueB2""],
  ""fieldC"": [1,2,3]
}
----

==== Single Field, No Sorting

[source,text]
----
cartesianProduct(
  search(collection1, q=""*:*"", qt=""/export"", fl=""fieldA, fieldB, fieldC"", sort=""fieldA asc""),
  fieldB
)

{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB1"",
  ""fieldC"": [1,2,3]
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB2"",
  ""fieldC"": [1,2,3]
}
----

==== Single Evaluator, No Sorting

[source,text]
----
cartesianProduct(
  search(collection1, q=""*:*"", qt=""/export"", fl=""fieldA, fieldB, fieldC"", sort=""fieldA asc""),
  sequence(3,4,5) as fieldE
)

{
  ""fieldA"": ""valueA"",
  ""fieldB"": [""valueB1"",""valueB2""],
  ""fieldC"": [1,2,3],
  ""fieldE"": 4
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": [""valueB1"",""valueB2""],
  ""fieldC"": [1,2,3],
  ""fieldE"": 9
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": [""valueB1"",""valueB2""],
  ""fieldC"": [1,2,3],
  ""fieldE"": 14
}
----

==== Single Field, Sorted by Value

[source,text]
----
cartesianProduct(
  search(collection1, q=""*:*"", qt=""/export"", fl=""fieldA, fieldB, fieldC"", sort=""fieldA asc""),
  fieldB,
  productSort=""fieldB desc""
)

{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB2"",
  ""fieldC"": [1,2,3]
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB1"",
  ""fieldC"": [1,2,3]
}
----

==== Single Evaluator, Sorted by Evaluator Values

[source,text]
----
cartesianProduct(
  search(collection1, q=""*:*"", qt=""/export"", fl=""fieldA, fieldB, fieldC"", sort=""fieldA asc""),
  sequence(3,4,5) as fieldE,
  productSort=""newFieldE desc""
)

{
  ""fieldA"": ""valueA"",
  ""fieldB"": [""valueB1"",""valueB2""],
  ""fieldC"": [1,2,3],
  ""fieldE"": 14
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": [""valueB1"",""valueB2""],
  ""fieldC"": [1,2,3],
  ""fieldE"": 9
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": [""valueB1"",""valueB2""],
  ""fieldC"": [1,2,3],
  ""fieldE"": 4
}
----

==== Renamed Single Field, Sorted by Value

[source,text]
----
cartesianProduct(
  search(collection1, q=""*:*"", qt=""/export"", fl=""fieldA, fieldB, fieldC"", sort=""fieldA asc""),
  fieldB as newFieldB,
  productSort=""fieldB desc""
)

{
  ""fieldA"": ""valueA"",
  ""fieldB"": [""valueB1"",""valueB2""],
  ""fieldC"": [1,2,3]
  ""newFieldB"": ""valueB2"",
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": [""valueB1"",""valueB2""],
  ""fieldC"": [1,2,3]
  ""newFieldB"": ""valueB1"",
}
----

==== Multiple Fields, No Sorting

[source,text]
----
cartesianProduct(
  search(collection1, q=""*:*"", qt=""/export"", fl=""fieldA, fieldB, fieldC"", sort=""fieldA asc""),
  fieldB,
  fieldC
)

{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB1"",
  ""fieldC"": 1
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB1"",
  ""fieldC"": 2
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB1"",
  ""fieldC"": 3
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB2"",
  ""fieldC"": 1
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB2"",
  ""fieldC"": 2
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB2"",
  ""fieldC"": 3
}
----

==== Multiple Fields, Sorted by Single Field

[source,text]
----
cartesianProduct(
  search(collection1, qt=""/export"", q=""*:*"", fl=""fieldA, fieldB, fieldC"", sort=""fieldA asc""),
  fieldB,
  fieldC,
  productSort=""fieldC asc""
)

{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB1"",
  ""fieldC"": 1
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB2"",
  ""fieldC"": 1
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB1"",
  ""fieldC"": 2
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB2"",
  ""fieldC"": 2
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB1"",
  ""fieldC"": 3
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB2"",
  ""fieldC"": 3
}
----

==== Multiple Fields, Sorted by Multiple Fields

[source,text]
----
cartesianProduct(
  search(collection1, q=""*:*"", qt=""/export"", fl=""fieldA, fieldB, fieldC"", sort=""fieldA asc""),
  fieldB,
  fieldC,
  productSort=""fieldC asc, fieldB desc""
)

{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB2"",
  ""fieldC"": 1
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB1"",
  ""fieldC"": 1
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB2"",
  ""fieldC"": 2
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB1"",
  ""fieldC"": 2
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB2"",
  ""fieldC"": 3
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": ""valueB1"",
  ""fieldC"": 3
}
----

==== Field and Evaluator, No Sorting

[source,text]
----
cartesianProduct(
  search(collection1, q=""*:*"", qt=""/export"", fl=""fieldA, fieldB, fieldC"", sort=""fieldA asc""),
  sequence(3,4,5) as fieldE,
  fieldB
)

{
  ""fieldA"": ""valueA"",
  ""fieldB"": valueB1,
  ""fieldC"": [1,2,3],
  ""fieldE"": 4
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": valueB2,
  ""fieldC"": [1,2,3],
  ""fieldE"": 4
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": valueB1,
  ""fieldC"": [1,2,3],
  ""fieldE"": 9
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": valueB2,
  ""fieldC"": [1,2,3],
  ""fieldE"": 9
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": valueB1,
  ""fieldC"": [1,2,3],
  ""fieldE"": 14
}
{
  ""fieldA"": ""valueA"",
  ""fieldB"": valueB2,
  ""fieldC"": [1,2,3],
  ""fieldE"": 14
}
----

As you can see in the examples above, the `cartesianProduct` function does support flattening tuples across multiple fields and/or evaluators.

== classify

The `classify` function classifies tuples using a logistic regression text classification model. It was designed specifically to work with models trained using the <<stream-source-reference.adoc#train,train function>>. The `classify` function uses the <<stream-source-reference.adoc#model,model function>> to retrieve a stored model and then scores a stream of tuples using the model. The tuples read by the classifier must contain a text field that can be used for classification. The classify function uses a Lucene analyzer to extract the features from the text so the model can be applied. By default the `classify` function looks for the analyzer using the name of text field in the tuple. If the Solr schema on the worker node does not contain this field, the analyzer can be looked up in another field by specifying the `analyzerField` parameter.

Each tuple that is classified is assigned two scores:

* probability_d*: A float between 0 and 1 which describes the probability that the tuple belongs to the class. This is useful in the classification use case.

* score_d*: The score of the document that has not be squashed between 0 and 1. The score may be positive or negative. The higher the score the better the document fits the class. This un-squashed score will be useful in query re-ranking and recommendation use cases. This score is particularly useful when multiple high ranking documents have a probability_d score of 1, which won't provide a meaningful ranking between documents.

=== classify Parameters

* `model expression`: (Mandatory) Retrieves the stored logistic regression model.
* `field`: (Mandatory) The field in the tuples to apply the classifier to. By default the analyzer for this field in the schema will be used extract the features.
* `analyzerField`: (Optional) Specifies a different field to find the analyzer from in the schema.

=== classify Syntax

[source,text]
----
classify(model(modelCollection,
             id=""model1"",
             cacheMillis=5000),
         search(contentCollection,
             q=""id:(a b c)"",
             qt=""/export"",
             fl=""text_t, id"",
             sort=""id asc""),
             field=""text_t"")
----

In the example above the `classify expression` is retrieving the model using the `model` function. It is then classifying tuples returned by the `search` function. The `text_t` field is used for the text classification and the analyzer for the `text_t` field in the Solr schema is used to analyze the text and extract the features.

== commit

The `commit` function wraps a single stream (A) and given a collection and batch size will send commit messages to the collection when the batch size is fulfilled or the end of stream is reached. A commit stream is used most frequently with an update stream and as such the commit will take into account possible summary tuples coming from the update stream. All tuples coming into the commit stream will be returned out of the commit stream - no tuples will be dropped and no tuples will be added.

=== commit Parameters

* `collection`: The collection to send commit messages to (required)
* `batchSize`: The commit batch size, sends commit message when batch size is hit. If not provided (or provided as value 0) then a commit is only sent at the end of the incoming stream.
* `waitFlush`: The value passed directly to the commit handler (true/false, default: false)
* `waitSearcher`: The value passed directly to the commit handler (true/false, default: false)
* `softCommit`: The value passed directly to the commit handler (true/false, default: false)
* `StreamExpression for StreamA` (required)

=== commit Syntax

[source,text]
----
commit(
    destinationCollection,
    batchSize=2,
    update(
        destinationCollection,
        batchSize=5,
        search(collection1, q=""*:*"", qt=""/export"", fl=""id,a_s,a_i,a_f,s_multi,i_multi"", sort=""a_f asc, a_i asc"")
    )
)
----

== complement

The `complement` function wraps two streams (A and B) and emits tuples from A which do not exist in B. The tuples are emitted in the order in which they appear in stream A. Both streams must be sorted by the fields being used to determine equality (using the `on` parameter).

=== complement Parameters

* `StreamExpression for StreamA`
* `StreamExpression for StreamB`
* `on`: Fields to be used for checking equality of tuples between A and B. Can be of the format `on=""fieldName""`, `on=""fieldNameInLeft=fieldNameInRight""`, or `on=""fieldName, otherFieldName=rightOtherFieldName""`.

=== complement Syntax

[source,text]
----
complement(
  search(collection1, q=""a_s:(setA || setAB)"", qt=""/export"", fl=""id,a_s,a_i"", sort=""a_i asc, a_s asc""),
  search(collection1, q=""a_s:(setB || setAB)"", qt=""/export"", fl=""id,a_s,a_i"", sort=""a_i asc""),
  on=""a_i""
)

complement(
  search(collection1, q=""a_s:(setA || setAB)"", qt=""/export"", fl=""id,a_s,a_i"", sort=""a_i asc, a_s asc""),
  search(collection1, q=""a_s:(setB || setAB)"", qt=""/export"", fl=""id,a_s,a_i"", sort=""a_i asc, a_s asc""),
  on=""a_i,a_s""
)
----

== daemon

The `daemon` function wraps another function and runs it at intervals using an internal thread. The `daemon` function can be used to provide both continuous push and pull streaming.

=== Continuous Push Streaming

With continuous push streaming the `daemon` function wraps another function and is then sent to the `/stream` handler for execution. The `/stream` handler recognizes the `daemon` function and keeps it resident in memory, so it can run its internal function at intervals.

In order to facilitate the pushing of tuples, the `daemon` function must wrap another stream decorator that pushes the tuples somewhere. One example of this is the `update` function, which wraps a stream and sends the tuples to another SolrCloud collection for indexing.

=== daemon Syntax

[source,text]
----
daemon(id=""uniqueId"",
       runInterval=""1000"",
       terminate=""true"",
       update(destinationCollection,
              batchSize=100,
              topic(checkpointCollection,
                    topicCollection,
                    q=""topic query"",
                    fl=""id, title, abstract, text"",
                    id=""topicId"",
                    initialCheckpoint=0)
               )
        )
----

The sample code above shows a `daemon` function wrapping an `update` function, which is wrapping a `topic` function. When this expression is sent to the `/stream` handler, the `/stream` hander sees the `daemon` function and keeps it in memory where it will run at intervals. In this particular example, the `daemon` function will run the `update` function every second. The `update` function is wrapping a <<stream-source-reference.adoc#topic,`topic` function>>, which will stream tuples that match the `topic` function query in batches. Each subsequent call to the topic will return the next batch of tuples for the topic. The `update` function will send all the tuples matching the topic to another collection to be indexed. The `terminate` parameter tells the daemon to terminate when the `topic` function stops sending tuples.

The effect of this is to push documents that match a specific query into another collection. Custom push functions can be plugged in that push documents out of Solr and into other systems, such as Kafka or an email system.

Push streaming can also be used for continuous background aggregation scenarios where aggregates are rolled up in the background at intervals and pushed to other Solr collections. Another use case is continuous background machine learning model optimization, where the optimized model is pushed to another Solr collection where it can be integrated into queries.

The `/stream` handler supports a small set commands for listing and controlling daemon functions:

[source,text]
----
http://localhost:8983/collection/stream?action=list
----

This command will provide a listing of the current daemon's running on the specific node along with there current state.

[source,text]
----
http://localhost:8983/collection/stream?action=stop&id=daemonId
----

This command will stop a specific daemon function but leave it resident in memory.

[source,text]
----
http://localhost:8983/collection/stream?action=start&id=daemonId
----

This command will start a specific daemon function that has been stopped.

[source,text]
----
http://localhost:8983/collection/stream?action=kill&id=daemonId
----

This command will stop a specific daemon function and remove it from memory.

=== Continuous Pull Streaming

The {solr-javadocs}/solr-solrj/org/apache/solr/client/solrj/io/stream/DaemonStream.html[DaemonStream] java class (part of the SolrJ libraries) can also be embedded in a java application to provide continuous pull streaming. Sample code:

[source,java]
----
StreamContext context = new StreamContext()
SolrClientCache cache = new SolrClientCache();
context.setSolrClientCache(cache);

Map topicQueryParams = new HashMap();
topicQueryParams.put(""q"",""hello"");  // The query for the topic
topicQueryparams.put(""rows"", ""500""); // How many rows to fetch during each run
topicQueryparams.put(""fl"", ""id"", ""title""); // The field list to return with the documents

TopicStream topicStream = new TopicStream(zkHost,        // Host address for the ZooKeeper service housing the collections
                                         ""checkpoints"",  // The collection to store the topic checkpoints
                                         ""topicData"",    // The collection to query for the topic records
                                         ""topicId"",      // The id of the topic
                                         -1,             // checkpoint every X tuples, if set -1 it will checkpoint after each run.
                                          topicQueryParams); // The query parameters for the TopicStream

DaemonStream daemonStream = new DaemonStream(topicStream,             // The underlying stream to run.
                                             ""daemonId"",              // The id of the daemon
                                             1000,                    // The interval at which to run the internal stream
                                             500);                    // The internal queue size for the daemon stream. Tuples will be placed in the queue
                                                                      // as they are read by the internal internal thread.
                                                                      // Calling read() on the daemon stream reads records from the internal queue.

daemonStream.setStreamContext(context);

daemonStream.open();

//Read until it's time to shutdown the DaemonStream. You can define the shutdown criteria.
while(!shutdown()) {
    Tuple tuple = daemonStream.read() // This will block until tuples become available from the underlying stream (TopicStream)
                                      // The EOF tuple (signaling the end of the stream) will never occur until the DaemonStream has been shutdown.
    //Do something with the tuples
}

// Shutdown the DaemonStream.
daemonStream.shutdown();

//Read the DaemonStream until the EOF Tuple is found.
//This allows the underlying stream to perform an orderly shutdown.

while(true) {
    Tuple tuple = daemonStream.read();
    if(tuple.EOF) {
        break;
    } else {
        //Do something with the tuples.
    }
}
//Finally close the stream
daemonStream.close();
----

== eval

The `eval` function allows for use cases where new streaming expressions are generated on the fly and then evaluated.
The `eval` function wraps a streaming expression and reads a single tuple from the underlying stream.
The `eval` function then retrieves a string Streaming Expressions from the `expr_s` field of the tuple.
The `eval` function then compiles the string Streaming Expression and emits the tuples.

=== eval Parameters

* `StreamExpression`: (Mandatory) The stream which provides the streaming expression to be evaluated.

=== eval Syntax

[source,text]
----
eval(expr)
----

In the example above the `eval` expression reads the first tuple from the underlying expression. It then compiles and
executes the string Streaming Expression in the epxr_s field.

== executor

The `executor` function wraps a stream source that contains streaming expressions, and executes the expressions in parallel. The `executor` function looks for the expression in the `expr_s` field in each tuple. The `executor` function has an internal thread pool that runs tasks that compile and run expressions in parallel on the same worker node. This function can also be parallelized across worker nodes by wrapping it in the <<parallel,`parallel`>> function to provide parallel execution of expressions across a cluster.

The `executor` function does not do anything specific with the output of the expressions that it runs. Therefore the expressions that are executed must contain the logic for pushing tuples to their destination. The <<update,update function>> can be included in the expression being executed to send the tuples to a SolrCloud collection for storage.

This model allows for asynchronous execution of jobs where the output is stored in a SolrCloud collection where it can be accessed as the job progresses.

=== executor Parameters

* `threads`: (Optional) The number of threads in the executors thread pool for executing expressions.
* `StreamExpression`: (Mandatory) The stream source which contains the Streaming Expressions to execute.

=== executor Syntax

[source,text]
----
daemon(id=""myDaemon"",
       terminate=""true"",
       executor(threads=10,
                topic(checkpointCollection
                      storedExpressions,
                      q=""*:*"",
                      fl=""id, expr_s"",
                      initialCheckPoint=0,
                      id=""myTopic"")))
----

In the example above a <<daemon,daemon>> wraps an executor, which wraps a <<stream-source-reference.adoc#topic,topic>> that is returning tuples with expressions to execute. When sent to the stream handler, the daemon will call the executor at intervals which will cause the executor to read from the topic and execute the expressions found in the `expr_s` field. The daemon will repeatedly call the executor until all the tuples that match the topic have been iterated, then it will terminate. This is the approach for executing batches of streaming expressions from a `topic` queue.

== fetch

The `fetch` function iterates a stream and fetches additional fields and adds them to the tuples. The `fetch` function fetches in batches to limit the number of calls back to Solr. Tuples streamed from the `fetch` function will contain the original fields and the additional fields that were fetched. The `fetch` function supports one-to-one fetches. Many-to-one fetches, where the stream source contains duplicate keys, will also work, but one-to-many fetches are currently not supported by this function.

=== fetch Parameters

* `Collection`: (Mandatory) The collection to fetch the fields from.
* `StreamExpression`: (Mandatory) The stream source for the fetch function.
* `fl`: (Mandatory) The fields to be fetched.
* `on`: Fields to be used for checking equality of tuples between stream source and fetched records. Formatted as `on=""fieldNameInTuple=fieldNameInCollection""`.
* `batchSize`: (Optional) The batch fetch size.

=== fetch Syntax

[source,text]
----
fetch(addresses,
      search(people, q=""*:*"", qt=""/export"", fl=""username, firstName, lastName"", sort=""username asc""),
      fl=""streetAddress, city, state, country, zip"",
      on=""username=userId"")
----

The example above fetches addresses for users by matching the username in the tuple with the userId field in the addresses collection.

== having

The `having` expression wraps a stream and applies a boolean operation to each tuple. It emits only tuples for which the boolean operation returns *true*.

=== having Parameters

* `StreamExpression`: (Mandatory) The stream source for the having function.
* `booleanEvaluator`: (Madatory) The following boolean operations are supported: `eq` (equals), `gt` (greater than), `lt` (less than), `gteq` (greater than or equal to), `lteq` (less than or equal to), `and`, `or`, `eor` (exclusive or), and `not`. Boolean evaluators can be nested with other evaluators to form complex boolean logic.

The comparison evaluators compare the value in a specific field with a value, whether a string, number, or boolean. For example: `eq(field1, 10)`, returns `true` if `field1` is equal to 10.

=== having Syntax

[source,text]
----
having(rollup(over=a_s,
              sum(a_i),
              search(collection1,
                     q=""*:*"",
                     qt=""/export"",
                     fl=""id,a_s,a_i,a_f"",
                     sort=""a_s asc"")),
       and(gt(sum(a_i), 100), lt(sum(a_i), 110)))

----

In this example, the `having` expression iterates the aggregated tuples from the `rollup` expression and emits all tuples where the field `sum(a_i)` is greater then 100 and less then 110.

== leftOuterJoin

The `leftOuterJoin` function wraps two streams, Left and Right, and emits tuples from Left. If there is a tuple in Right equal (as defined by `on`) then the values in that tuple will be included in the emitted tuple. An equal tuple in Right *need not* exist for the Left tuple to be emitted. This supports one-to-one, one-to-many, many-to-one, and many-to-many left outer join scenarios. The tuples are emitted in the order in which they appear in the Left stream. Both streams must be sorted by the fields being used to determine equality (using the `on` parameter). If both tuples contain a field of the same name then the value from the Right stream will be used in the emitted tuple.

You can wrap the incoming streams with a `select` function to be specific about which field values are included in the emitted tuple.

=== leftOuterJoin Parameters

* `StreamExpression for StreamLeft`
* `StreamExpression for StreamRight`
* `on`: Fields to be used for checking equality of tuples between Left and Right. Can be of the format `on=""fieldName""`, `on=""fieldNameInLeft=fieldNameInRight""`, or `on=""fieldName, otherFieldName=rightOtherFieldName""`.

=== leftOuterJoin Syntax

[source,text]
----
leftOuterJoin(
  search(people, q=""*:*"", qt=""/export"", fl=""personId,name"", sort=""personId asc""),
  search(pets, q=""type:cat"", qt=""/export"", fl=""personId,petName"", sort=""personId asc""),
  on=""personId""
)

leftOuterJoin(
  search(people, q=""*:*"", qt=""/export"", fl=""personId,name"", sort=""personId asc""),
  search(pets, q=""type:cat"", qt=""/export"", fl=""ownerId,petName"", sort=""ownerId asc""),
  on=""personId=ownerId""
)

leftOuterJoin(
  search(people, q=""*:*"", qt=""/export"", fl=""personId,name"", sort=""personId asc""),
  select(
    search(pets, q=""type:cat"", qt=""/export"", fl=""ownerId,name"", sort=""ownerId asc""),
    ownerId,
    name as petName
  ),
  on=""personId=ownerId""
)
----

== hashJoin

The `hashJoin` function wraps two streams, Left and Right, and for every tuple in Left which exists in Right will emit a tuple containing the fields of both tuples. This supports one-to-one, one-to-many, many-to-one, and many-to-many inner join scenarios. The tuples are emitted in the order in which they appear in the Left stream. The order of the streams does not matter. If both tuples contain a field of the same name then the value from the Right stream will be used in the emitted tuple.

You can wrap the incoming streams with a `select` function to be specific about which field values are included in the emitted tuple.

The hashJoin function can be used when the tuples of Left and Right cannot be put in the same order. Because the tuples are out of order this stream functions by reading all values from the Right stream during the open operation and will store all tuples in memory. The result of this is a memory footprint equal to the size of the Right stream.

=== hashJoin Parameters

* `StreamExpression for StreamLeft`
* `hashed=StreamExpression for StreamRight`
* `on`: Fields to be used for checking equality of tuples between Left and Right. Can be of the format `on=""fieldName""`, `on=""fieldNameInLeft=fieldNameInRight""`, or `on=""fieldName, otherFieldName=rightOtherFieldName""`.

=== hashJoin Syntax

[source,text]
----
hashJoin(
  search(people, q=""*:*"", qt=""/export"", fl=""personId,name"", sort=""personId asc""),
  hashed=search(pets, q=""type:cat"", qt=""/export"", fl=""personId,petName"", sort=""personId asc""),
  on=""personId""
)

hashJoin(
  search(people, q=""*:*"", fl=""personId,name"", sort=""personId asc""),
  hashed=search(pets, q=""type:cat"", qt=""/export"", fl=""ownerId,petName"", sort=""ownerId asc""),
  on=""personId=ownerId""
)

hashJoin(
  search(people, q=""*:*"", qt=""/export"", fl=""personId,name"", sort=""personId asc""),
  hashed=select(
    search(pets, q=""type:cat"", qt=""/export"", fl=""ownerId,name"", sort=""ownerId asc""),
    ownerId,
    name as petName
  ),
  on=""personId=ownerId""
)
----

== innerJoin

Wraps two streams, Left and Right. For every tuple in Left which exists in Right a tuple containing the fields of both tuples will be emitted. This supports one-to-one, one-to-many, many-to-one, and many-to-many inner join scenarios. The tuples are emitted in the order in which they appear in the Left stream. Both streams must be sorted by the fields being used to determine equality (the 'on' parameter). If both tuples contain a field of the same name then the value from the Right stream will be used in the emitted tuple. You can wrap the incoming streams with a `select(...)` expression to be specific about which field values are included in the emitted tuple.

=== innerJoin Parameters

* `StreamExpression for StreamLeft`
* `StreamExpression for StreamRight`
* `on`: Fields to be used for checking equality of tuples between Left and Right. Can be of the format `on=""fieldName""`, `on=""fieldNameInLeft=fieldNameInRight""`, or `on=""fieldName, otherFieldName=rightOtherFieldName""`.

=== innerJoin Syntax

[source,text]
----
innerJoin(
  search(people, q=""*:*"", qt=""/export"", fl=""personId,name"", sort=""personId asc""),
  search(pets, q=""type:cat"", qt=""/export"", fl=""personId,petName"", sort=""personId asc""),
  on=""personId""
)

innerJoin(
  search(people, q=""*:*"", qt=""/export"", fl=""personId,name"", sort=""personId asc""),
  search(pets, q=""type:cat"", qt=""/export"", fl=""ownerId,petName"", sort=""ownerId asc""),
  on=""personId=ownerId""
)

innerJoin(
  search(people, q=""*:*"", qt=""/export"", fl=""personId,name"", sort=""personId asc""),
  select(
    search(pets, q=""type:cat"", qt=""/export"", fl=""ownerId,name"", sort=""ownerId asc""),
    ownerId,
    name as petName
  ),
  on=""personId=ownerId""
)
----

== intersect

The `intersect` function wraps two streams, A and B, and emits tuples from A which *DO* exist in B. The tuples are emitted in the order in which they appear in stream A. Both streams must be sorted by the fields being used to determine equality (the `on` parameter). Only tuples from A are emitted.

=== intersect Parameters

* `StreamExpression for StreamA`
* `StreamExpression for StreamB`
* `on`: Fields to be used for checking equality of tuples between A and B. Can be of the format `on=""fieldName""`, `on=""fieldNameInLeft=fieldNameInRight""`, or `on=""fieldName, otherFieldName=rightOtherFieldName""`.

=== intersect Syntax

[source,text]
----
intersect(
  search(collection1, q=""a_s:(setA || setAB)"", qt=""/export"", fl=""id,a_s,a_i"", sort=""a_i asc, a_s asc""),
  search(collection1, q=""a_s:(setB || setAB)"", qt=""/export"", fl=""id,a_s,a_i"", sort=""a_i asc""),
  on=""a_i""
)

intersect(
  search(collection1, q=""a_s:(setA || setAB)"", qt=""/export"", fl=""id,a_s,a_i"", sort=""a_i asc, a_s asc""),
  search(collection1, q=""a_s:(setB || setAB)"", qt=""/export"", fl=""id,a_s,a_i"", sort=""a_i asc, a_s asc""),
  on=""a_i,a_s""
)
----

== merge

The `merge` function merges two or more streaming expressions and maintains the ordering of the underlying streams. Because the order is maintained, the sorts of the underlying streams must line up with the on parameter provided to the merge function.

=== merge Parameters

* `StreamExpression A`
* `StreamExpression B`
* `Optional StreamExpression C,D,....Z`
* `on`: Sort criteria for performing the merge. Of the form `fieldName order` where order is `asc` or `desc`. Multiple fields can be provided in the form `fieldA order, fieldB order`.

=== merge Syntax

[source,text]
----
# Merging two stream expressions together
merge(
      search(collection1,
             q=""id:(0 3 4)"",
             qt=""/export"",
             fl=""id,a_s,a_i,a_f"",
             sort=""a_f asc""),
      search(collection1,
             q=""id:(1)"",
             qt=""/export"",
             fl=""id,a_s,a_i,a_f"",
             sort=""a_f asc""),
      on=""a_f asc"")
----

[source,text]
----
# Merging four stream expressions together. Notice that while the sorts of each stream are not identical they are
# comparable. That is to say the first N fields in each stream's sort matches the N fields in the merge's on clause.
merge(
      search(collection1,
             q=""id:(0 3 4)"",
             qt=""/export"",
             fl=""id,fieldA,fieldB,fieldC"",
             sort=""fieldA asc, fieldB desc""),
      search(collection1,
             q=""id:(1)"",
             qt=""/export"",
             fl=""id,fieldA"",
             sort=""fieldA asc""),
      search(collection2,
             q=""id:(10 11 13)"",
             qt=""/export"",
             fl=""id,fieldA,fieldC"",
             sort=""fieldA asc""),
      search(collection3,
             q=""id:(987)"",
             qt=""/export"",
             fl=""id,fieldA,fieldC"",
             sort=""fieldA asc""),
      on=""fieldA asc"")
----

== null

The null expression is a useful utility function for understanding bottlenecks when performing parallel relational algebra (joins, intersections, rollups etc.). The null function reads all the tuples from an underlying stream and returns a single tuple with the count and processing time. Because the null stream adds minimal overhead of it's own, it can be used to isolate the performance of Solr's /export handler. If the /export handlers performance is not the bottleneck, then the bottleneck is likely occurring in the workers where the stream decorators are running.

The null expression can be wrapped by the parallel function and sent to worker nodes. In this scenario each worker will return one tuple with the count of tuples processed on the worker and the timing information for that worker. This gives valuable information such as:

1.  As more workers are added does the performance of the /export handler improve or not.
2.  Are tuples being evenly distributed across the workers, or is the hash partitioning sending more documents to a single worker.
3.  Are all workers processing data at the same speed, or is one of the workers the source of the bottleneck.

=== null Parameters

* `StreamExpression`: (Mandatory) The expression read by the null function.

=== null Syntax

[source,text]
----
 parallel(workerCollection,
          null(search(collection1, q=""*:*"", fl=""id,a_s,a_i,a_f"", sort=""a_s desc"", qt=""/export"", partitionKeys=""a_s"")),
          workers=""20"",
          zkHost=""localhost:9983"",
          sort=""a_s desc"")
----

The expression above shows a parallel function wrapping a null function. This will cause the null function to be run in parallel across 20 worker nodes. Each worker will return a single tuple with number of tuples processed and time it took to iterate the tuples.

== outerHashJoin

The `outerHashJoin` function wraps two streams, Left and Right, and emits tuples from Left. If there is a tuple in Right equal (as defined by the `on` parameter) then the values in that tuple will be included in the emitted tuple. An equal tuple in Right *need not* exist for the Left tuple to be emitted. This supports one-to-one, one-to-many, many-to-one, and many-to-many left outer join scenarios. The tuples are emitted in the order in which they appear in the Left stream. The order of the streams does not matter. If both tuples contain a field of the same name then the value from the Right stream will be used in the emitted tuple.

You can wrap the incoming streams with a `select` function to be specific about which field values are included in the emitted tuple.

The outerHashJoin stream can be used when the tuples of Left and Right cannot be put in the same order. Because the tuples are out of order, this stream functions by reading all values from the Right stream during the open operation and will store all tuples in memory. The result of this is a memory footprint equal to the size of the Right stream.

=== outerHashJoin Parameters

* `StreamExpression for StreamLeft`
* `hashed=StreamExpression for StreamRight`
* `on`: Fields to be used for checking equality of tuples between Left and Right. Can be of the format `on=""fieldName""`, `on=""fieldNameInLeft=fieldNameInRight""`, or `on=""fieldName, otherFieldName=rightOtherFieldName""`.

=== outerHashJoin Syntax

[source,text]
----
outerHashJoin(
  search(people, q=""*:*"", qt=""/export"", fl=""personId,name"", sort=""personId asc""),
  hashed=search(pets, q=""type:cat"", qt=""/export"", fl=""personId,petName"", sort=""personId asc""),
  on=""personId""
)

outerHashJoin(
  search(people, q=""*:*"", qt=""/export"", fl=""personId,name"", sort=""personId asc""),
  hashed=search(pets, q=""type:cat"", qt=""/export"", fl=""ownerId,petName"", sort=""ownerId asc""),
  on=""personId=ownerId""
)

outerHashJoin(
  search(people, q=""*:*"", qt=""/export"", fl=""personId,name"", sort=""personId asc""),
  hashed=select(
    search(pets, q=""type:cat"", qt=""/export"", fl=""ownerId,name"", sort=""ownerId asc""),
    ownerId,
    name as petName
  ),
  on=""personId=ownerId""
)
----

== parallel

The `parallel` function wraps a streaming expression and sends it to N worker nodes to be processed in parallel.

The `parallel` function requires that the `partitionKeys` parameter be provided to the underlying searches. The `partitionKeys` parameter will partition the search results (tuples) across the worker nodes. Tuples with the same values in for `partitionKeys` will be shuffled to the same worker nodes.

The `parallel` function maintains the sort order of the tuples returned by the worker nodes, so the sort criteria must incorporate the sort order of the tuples returned by the workers.

For example if you sort on year, month and day you could partition on year only as long as there are enough different years to spread the tuples around the worker nodes.

Solr allows sorting on more than 4 fields, but you cannot specify more than 4 partitionKeys for speed considerations. Also it's overkill to specify many `partitionKeys` when we one or two keys could be enough to spread the tuples.

Parallel stream was designed when the underlying search stream will emit a lot of tuples from the collection. If the search stream only emits a small subset of the data from the collection using `parallel` could potentially be slower.

.Worker Collections
[TIP]
====
The worker nodes can be from the same collection as the data, or they can be a different collection entirely, even one that only exists for `parallel` streaming expressions. A worker collection can be any SolrCloud collection that has the `/stream` handler configured. Unlike normal SolrCloud collections, worker collections don't have to hold any data. Worker collections can be empty collections that exist only to execute streaming expressions.
====

=== parallel Parameters

* `collection`: Name of the worker collection to send the StreamExpression to.
* `StreamExpression`: Expression to send to the worker collection.
* `workers`: Number of workers in the worker collection to send the expression to.
* `zkHost`: (Optional) The ZooKeeper connect string where the worker collection resides.
* `sort`: The sort criteria for ordering tuples returned by the worker nodes.

=== parallel Syntax

[source,text]
----
 parallel(workerCollection,
          rollup(search(collection1, q=""*:*"", fl=""id,year_i,month_i,day_i"", qt=""/export"", sort=""year_i desc,month_i desc,day_i asc"", partitionKeys=""year_i""),
                 over=""year_i"", count(*)),
          workers=""20"",
          zkHost=""localhost:9983"",
          sort=""year_i desc"")
----

The expression above shows a `parallel` function wrapping a `reduce` function. This will cause the `reduce` function to be run in parallel across 20 worker nodes.

.Warmup
[TIP]
====
The `parallel` function uses the hash query parser to split the data amongst the workers. It executes on all the documents and the result bitset is cached in the filterCache.
+
For a `parallel` stream with the same number of workers and `partitonKeys` the first query would be slower than subsequent queries.
A trick to not pay the penalty for the first slow query would be to use a warmup query for every new searcher.
The following is a `solrconfig.xml` snippet for 2 workers and ""year_i"" as the `partionKeys`.

[source,text]
----
<listener event=""newSearcher"" class=""solr.QuerySenderListener"">
<arr name=""queries"">
    <lst><str name=""q"">:</str><str name=""fq"">{!hash workers=2 worker=0}</str><str name=""partitionKeys"">year_i</str></lst>
    <lst><str name=""q"">:</str><str name=""fq"">{!hash workers=2 worker=1}</str><str name=""partitionKeys"">year_i</str></lst>
</arr>
</listener>
----
====

== priority

The `priority` function is a simple priority scheduler for the <<executor>> function. The `executor` function doesn't directly have a concept of task prioritization; instead it simply executes tasks in the order that they are read from it's underlying stream. The `priority` function provides the ability to schedule a higher priority task ahead of lower priority tasks that were submitted earlier.

The `priority` function wraps two <<stream-source-reference.adoc#topic,topics>> that are both emitting tuples that contain streaming expressions to execute. The first topic is considered the higher priority task queue.

Each time the `priority` function is called, it checks the higher priority task queue to see if there are any tasks to execute. If tasks are waiting in the higher priority queue then the priority function will emit the higher priority tasks. If there are no high priority tasks to run, the lower priority queue tasks are emitted.

The `priority` function will only emit a batch of tasks from one of the queues each time it is called. This ensures that no lower priority tasks are executed until the higher priority queue has no tasks to run.

=== priority Parameters

* `topic expression`: (Mandatory) the high priority task queue
* `topic expression`: (Mandatory) the lower priority task queue

=== priority Syntax

[source,text]
----
daemon(id=""myDaemon"",
       executor(threads=10,
                priority(topic(checkpointCollection, storedExpressions, q=""priority:high"", fl=""id, expr_s"", initialCheckPoint=0,id=""highPriorityTasks""),
                         topic(checkpointCollection, storedExpressions, q=""priority:low"", fl=""id, expr_s"", initialCheckPoint=0,id=""lowPriorityTasks""))))
----

In the example above the `daemon` function is calling the executor iteratively. Each time it's called, the `executor` function will execute the tasks emitted by the `priority` function. The `priority` function wraps two topics. The first topic is the higher priority task queue, the second topics is the lower priority topic.

== reduce

The `reduce` function wraps an internal stream and groups tuples by common fields.

Each tuple group is operated on as a single block by a pluggable reduce operation. The group operation provided with Solr implements distributed grouping functionality. The group operation also serves as an example reduce operation that can be referred to when building custom reduce operations.

[IMPORTANT]
====
The reduce function relies on the sort order of the underlying stream. Accordingly the sort order of the underlying stream must be aligned with the group by field.
====

=== reduce Parameters

* `StreamExpression`: (Mandatory)
* `by`: (Mandatory) A comma separated list of fields to group by.
* `Reduce Operation`: (Mandatory)

=== reduce Syntax

[source,text]
----
reduce(search(collection1, q=""*:*"", qt=""/export"", fl=""id,a_s,a_i,a_f"", sort=""a_s asc, a_f asc""),
       by=""a_s"",
       group(sort=""a_f desc"", n=""4"")
)
----

== rollup

The `rollup` function wraps another stream function and rolls up aggregates over bucket fields. The rollup function relies on the sort order of the underlying stream to rollup aggregates one grouping at a time. Accordingly, the sort order of the underlying stream must match the fields in the `over` parameter of the rollup function.

The rollup function also needs to process entire result sets in order to perform its aggregations. When the underlying stream is the `search` function, the `/export` handler can be used to provide full sorted result sets to the rollup function. This sorted approach allows the rollup function to perform aggregations over very high cardinality fields. The disadvantage of this approach is that the tuples must be sorted and streamed across the network to a worker node to be aggregated. For faster aggregation over low to moderate cardinality fields, the `facet` function can be used.

=== rollup Parameters

* `StreamExpression` (Mandatory)
* `over`: (Mandatory) A list of fields to group by.
* `metrics`: (Mandatory) The list of metrics to compute. Currently supported metrics are `sum(col)`, `avg(col)`, `min(col)`, `max(col)`, `count(*)`.

=== rollup Syntax

[source,text]
----
rollup(
   search(collection1, q=""*:*"", qt=""/export"", fl=""a_s,a_i,a_f"", qt=""/export"", sort=""a_s asc""),
   over=""a_s"",
   sum(a_i),
   sum(a_f),
   min(a_i),
   min(a_f),
   max(a_i),
   max(a_f),
   avg(a_i),
   avg(a_f),
   count(*)
)
----

The example about shows the rollup function wrapping the search function. Notice that search function is using the `/export` handler to provide the entire result set to the rollup stream. Also notice that the search function's *sort param* matches up with the rollup's `over` parameter. This allows the rollup function to rollup the over the `a_s` field, one group at a time.

== scoreNodes

See section in <<graph-traversal.adoc#using-the-scorenodes-function-to-make-a-recommendation,graph traversal>>.

== select

The `select` function wraps a streaming expression and outputs tuples containing a subset or modified set of fields from the incoming tuples. The list of fields included in the output tuple can contain aliases to effectively rename fields. The `select` stream supports both operations and evaluators. One can provide a list of operations and evaluators to perform on any fields, such as `replace, add, if`, etc.

=== select Parameters

* `StreamExpression`
* `fieldName`: name of field to include in the output tuple (can include multiple of these), such as `outputTuple[fieldName] = inputTuple[fieldName]`
* `fieldName as aliasFieldName`: aliased field name to include in the output tuple (can include multiple of these), such as `outputTuple[aliasFieldName] = incomingTuple[fieldName]`
* `replace(fieldName, value, withValue=replacementValue)`: if `incomingTuple[fieldName] == value` then `outgoingTuple[fieldName]` will be set to `replacementValue`. `value` can be the string ""null"" to replace a null value with some other value.
* `replace(fieldName, value, withField=otherFieldName)`: if `incomingTuple[fieldName] == value` then `outgoingTuple[fieldName]` will be set to the value of `incomingTuple[otherFieldName]`. `value` can be the string ""null"" to replace a null value with some other value.

=== select Syntax

[source,text]
----
// output tuples with fields teamName, wins, losses, and winPercentages where a null value for wins or losses is translated to the value of 0
select(
  search(collection1, fl=""id,teamName_s,wins,losses"", q=""*:*"", qt=""/export"", sort=""id asc""),
  teamName_s as teamName,
  wins,
  losses,
  replace(wins,null,withValue=0),
  replace(losses,null,withValue=0),
  if(eq(0,wins), 0, div(add(wins,losses), wins)) as winPercentage
)
----

== sort

The `sort` function wraps a streaming expression and re-orders the tuples. The sort function emits all incoming tuples in the new sort order. The sort function reads all tuples from the incoming stream, re-orders them using an algorithm with `O(nlog(n))` performance characteristics, where n is the total number of tuples in the incoming stream, and then outputs the tuples in the new sort order. Because all tuples are read into memory, the memory consumption of this function grows linearly with the number of tuples in the incoming stream.

=== sort Parameters

* `StreamExpression`
* `by`: Sort criteria for re-ordering the tuples

=== sort Syntax

The expression below finds dog owners and orders the results by owner and pet name. Notice that it uses an efficient innerJoin by first ordering by the person/owner id and then re-orders the final output by the owner and pet names.

[source,text]
----
sort(
  innerJoin(
    search(people, q=""*:*"", qt=""/export"", fl=""id,name"", sort=""id asc""),
    search(pets, q=""type:dog"", qt=""/export"", fl=""owner,petName"", sort=""owner asc""),
    on=""id=owner""
  ),
  by=""name asc, petName asc""
)
----

== top

The `top` function wraps a streaming expression and re-orders the tuples. The top function emits only the top N tuples in the new sort order. The top function re-orders the underlying stream so the sort criteria *does not* have to match up with the underlying stream.

=== top Parameters

* `n`: Number of top tuples to return.
* `StreamExpression`
* `sort`: Sort criteria for selecting the top N tuples.

=== top Syntax

The expression below finds the top 3 results of the underlying search. Notice that it reverses the sort order. The top function re-orders the results of the underlying stream.

[source,text]
----
top(n=3,
     search(collection1,
            q=""*:*"",
            qt=""/export"",
            fl=""id,a_s,a_i,a_f"",
            sort=""a_f desc, a_i desc""),
      sort=""a_f asc, a_i asc"")
----

== unique

The `unique` function wraps a streaming expression and emits a unique stream of tuples based on the `over` parameter. The unique function relies on the sort order of the underlying stream. The `over` parameter must match up with the sort order of the underlying stream.

The unique function implements a non-co-located unique algorithm. This means that records with the same unique `over` field do not need to be co-located on the same shard. When executed in the parallel, the `partitionKeys` parameter must be the same as the unique `over` field so that records with the same keys will be shuffled to the same worker.

=== unique Parameters

* `StreamExpression`
* `over`: The unique criteria.

=== unique Syntax

[source,text]
----
unique(
  search(collection1,
         q=""*:*"",
         qt=""/export"",
         fl=""id,a_s,a_i,a_f"",
         sort=""a_f asc, a_i asc""),
  over=""a_f"")
----

== update

The `update` function wraps another functions and sends the tuples to a SolrCloud collection for indexing.

=== update Parameters

* `destinationCollection`: (Mandatory) The collection where the tuples will indexed.
* `batchSize`: (Mandatory) The indexing batch size.
* `StreamExpression`: (Mandatory)

=== update Syntax

[source,text]
----
 update(destinationCollection,
        batchSize=500,
        search(collection1,
               q=*:*,
               qt=""/export"",
               fl=""id,a_s,a_i,a_f,s_multi,i_multi"",
               sort=""a_f asc, a_i asc""))

----

The example above sends the tuples returned by the `search` function to the `destinationCollection` to be indexed.
",12292,False,2242.8534541001814,median
"/*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.
//
//
//                           License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009, Willow Garage Inc., 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 the copyright holders 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*/

#ifndef __OPENCV_IMGPROC_HPP__
#define __OPENCV_IMGPROC_HPP__

#include ""opencv2/core.hpp""

/*! \\namespace cv
 Namespace where all the C++ OpenCV functionality resides
 */
namespace cv
{

//! type of the kernel
enum { KERNEL_GENERAL      = 0, // the kernel is generic. No any type of symmetry or other properties.
       KERNEL_SYMMETRICAL  = 1, // kernel[i] == kernel[ksize-i-1] , and the anchor is at the center
       KERNEL_ASYMMETRICAL = 2, // kernel[i] == -kernel[ksize-i-1] , and the anchor is at the center
       KERNEL_SMOOTH       = 4, // all the kernel elements are non-negative and summed to 1
       KERNEL_INTEGER      = 8  // all the kernel coefficients are integer numbers
     };

//! type of morphological operation
enum { MORPH_ERODE    = 0,
       MORPH_DILATE   = 1,
       MORPH_OPEN     = 2,
       MORPH_CLOSE    = 3,
       MORPH_GRADIENT = 4,
       MORPH_TOPHAT   = 5,
       MORPH_BLACKHAT = 6
     };

//! shape of the structuring element
enum { MORPH_RECT    = 0,
       MORPH_CROSS   = 1,
       MORPH_ELLIPSE = 2
     };

//! interpolation algorithm
enum { INTER_NEAREST        = 0, //!< nearest neighbor interpolation
       INTER_LINEAR         = 1, //!< bilinear interpolation
       INTER_CUBIC          = 2, //!< bicubic interpolation
       INTER_AREA           = 3, //!< area-based (or super) interpolation
       INTER_LANCZOS4       = 4, //!< Lanczos interpolation over 8x8 neighborhood

       INTER_MAX            = 7, //!< mask for interpolation codes
       WARP_FILL_OUTLIERS   = 8,
       WARP_INVERSE_MAP     = 16
     };

enum { INTER_BITS      = 5,
       INTER_BITS2     = INTER_BITS * 2,
       INTER_TAB_SIZE  = 1 << INTER_BITS,
       INTER_TAB_SIZE2 = INTER_TAB_SIZE * INTER_TAB_SIZE
     };

//! Distance types for Distance Transform and M-estimators
enum { DIST_USER    = -1,  // User defined distance
       DIST_L1      = 1,   // distance = |x1-x2| + |y1-y2|
       DIST_L2      = 2,   // the simple euclidean distance
       DIST_C       = 3,   // distance = max(|x1-x2|,|y1-y2|)
       DIST_L12     = 4,   // L1-L2 metric: distance = 2(sqrt(1+x*x/2) - 1))
       DIST_FAIR    = 5,   // distance = c^2(|x|/c-log(1+|x|/c)), c = 1.3998
       DIST_WELSCH  = 6,   // distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846
       DIST_HUBER   = 7    // distance = |x|<c ? x^2/2 : c(|x|-c/2), c=1.345
};

//! Mask size for distance transform
enum { DIST_MASK_3       = 3,
       DIST_MASK_5       = 5,
       DIST_MASK_PRECISE = 0
     };

//! type of the threshold operation
enum { THRESH_BINARY     = 0, // value = value > threshold ? max_value : 0
       THRESH_BINARY_INV = 1, // value = value > threshold ? 0 : max_value
       THRESH_TRUNC      = 2, // value = value > threshold ? threshold : value
       THRESH_TOZERO     = 3, // value = value > threshold ? value : 0
       THRESH_TOZERO_INV = 4, // value = value > threshold ? 0 : value
       THRESH_MASK       = 7,
       THRESH_OTSU       = 8  // use Otsu algorithm to choose the optimal threshold value
     };

//! adaptive threshold algorithm
enum { ADAPTIVE_THRESH_MEAN_C     = 0,
       ADAPTIVE_THRESH_GAUSSIAN_C = 1
     };

enum { PROJ_SPHERICAL_ORTHO  = 0,
       PROJ_SPHERICAL_EQRECT = 1
     };

//! class of the pixel in GrabCut algorithm
enum { GC_BGD    = 0,  //!< background
       GC_FGD    = 1,  //!< foreground
       GC_PR_BGD = 2,  //!< most probably background
       GC_PR_FGD = 3   //!< most probably foreground
     };

//! GrabCut algorithm flags
enum { GC_INIT_WITH_RECT  = 0,
       GC_INIT_WITH_MASK  = 1,
       GC_EVAL            = 2
};

//! distanceTransform algorithm flags
enum { DIST_LABEL_CCOMP = 0,
       DIST_LABEL_PIXEL = 1
     };

//! floodfill algorithm flags
enum { FLOODFILL_FIXED_RANGE = 1 << 16,
       FLOODFILL_MASK_ONLY   = 1 << 17
     };

//! type of the template matching operation
enum { TM_SQDIFF        = 0,
       TM_SQDIFF_NORMED = 1,
       TM_CCORR         = 2,
       TM_CCORR_NORMED  = 3,
       TM_CCOEFF        = 4,
       TM_CCOEFF_NORMED = 5
     };

//! connected components algorithm output formats
enum { CC_STAT_LEFT   = 0,
       CC_STAT_TOP    = 1,
       CC_STAT_WIDTH  = 2,
       CC_STAT_HEIGHT = 3,
       CC_STAT_AREA   = 4,
       CC_STAT_MAX    = 5
     };

//! mode of the contour retrieval algorithm
enum { RETR_EXTERNAL  = 0, //!< retrieve only the most external (top-level) contours
       RETR_LIST      = 1, //!< retrieve all the contours without any hierarchical information
       RETR_CCOMP     = 2, //!< retrieve the connected components (that can possibly be nested)
       RETR_TREE      = 3, //!< retrieve all the contours and the whole hierarchy
       RETR_FLOODFILL = 4
     };

//! the contour approximation algorithm
enum { CHAIN_APPROX_NONE      = 1,
       CHAIN_APPROX_SIMPLE    = 2,
       CHAIN_APPROX_TC89_L1   = 3,
       CHAIN_APPROX_TC89_KCOS = 4
     };

//! Variants of a Hough transform
enum { HOUGH_STANDARD      = 0,
       HOUGH_PROBABILISTIC = 1,
       HOUGH_MULTI_SCALE   = 2,
       HOUGH_GRADIENT      = 3
     };

//! Variants of Line Segment Detector
enum { LSD_REFINE_NONE = 0,
       LSD_REFINE_STD  = 1,
       LSD_REFINE_ADV  = 2
     };

//! Histogram comparison methods
enum { HISTCMP_CORREL        = 0,
       HISTCMP_CHISQR        = 1,
       HISTCMP_INTERSECT     = 2,
       HISTCMP_BHATTACHARYYA = 3,
       HISTCMP_HELLINGER     = HISTCMP_BHATTACHARYYA,
       HISTCMP_CHISQR_ALT    = 4
     };

//! the color conversion code
enum { COLOR_BGR2BGRA     = 0,
       COLOR_RGB2RGBA     = COLOR_BGR2BGRA,

       COLOR_BGRA2BGR     = 1,
       COLOR_RGBA2RGB     = COLOR_BGRA2BGR,

       COLOR_BGR2RGBA     = 2,
       COLOR_RGB2BGRA     = COLOR_BGR2RGBA,

       COLOR_RGBA2BGR     = 3,
       COLOR_BGRA2RGB     = COLOR_RGBA2BGR,

       COLOR_BGR2RGB      = 4,
       COLOR_RGB2BGR      = COLOR_BGR2RGB,

       COLOR_BGRA2RGBA    = 5,
       COLOR_RGBA2BGRA    = COLOR_BGRA2RGBA,

       COLOR_BGR2GRAY     = 6,
       COLOR_RGB2GRAY     = 7,
       COLOR_GRAY2BGR     = 8,
       COLOR_GRAY2RGB     = COLOR_GRAY2BGR,
       COLOR_GRAY2BGRA    = 9,
       COLOR_GRAY2RGBA    = COLOR_GRAY2BGRA,
       COLOR_BGRA2GRAY    = 10,
       COLOR_RGBA2GRAY    = 11,

       COLOR_BGR2BGR565   = 12,
       COLOR_RGB2BGR565   = 13,
       COLOR_BGR5652BGR   = 14,
       COLOR_BGR5652RGB   = 15,
       COLOR_BGRA2BGR565  = 16,
       COLOR_RGBA2BGR565  = 17,
       COLOR_BGR5652BGRA  = 18,
       COLOR_BGR5652RGBA  = 19,

       COLOR_GRAY2BGR565  = 20,
       COLOR_BGR5652GRAY  = 21,

       COLOR_BGR2BGR555   = 22,
       COLOR_RGB2BGR555   = 23,
       COLOR_BGR5552BGR   = 24,
       COLOR_BGR5552RGB   = 25,
       COLOR_BGRA2BGR555  = 26,
       COLOR_RGBA2BGR555  = 27,
       COLOR_BGR5552BGRA  = 28,
       COLOR_BGR5552RGBA  = 29,

       COLOR_GRAY2BGR555  = 30,
       COLOR_BGR5552GRAY  = 31,

       COLOR_BGR2XYZ      = 32,
       COLOR_RGB2XYZ      = 33,
       COLOR_XYZ2BGR      = 34,
       COLOR_XYZ2RGB      = 35,

       COLOR_BGR2YCrCb    = 36,
       COLOR_RGB2YCrCb    = 37,
       COLOR_YCrCb2BGR    = 38,
       COLOR_YCrCb2RGB    = 39,

       COLOR_BGR2HSV      = 40,
       COLOR_RGB2HSV      = 41,

       COLOR_BGR2Lab      = 44,
       COLOR_RGB2Lab      = 45,

       COLOR_BGR2Luv      = 50,
       COLOR_RGB2Luv      = 51,
       COLOR_BGR2HLS      = 52,
       COLOR_RGB2HLS      = 53,

       COLOR_HSV2BGR      = 54,
       COLOR_HSV2RGB      = 55,

       COLOR_Lab2BGR      = 56,
       COLOR_Lab2RGB      = 57,
       COLOR_Luv2BGR      = 58,
       COLOR_Luv2RGB      = 59,
       COLOR_HLS2BGR      = 60,
       COLOR_HLS2RGB      = 61,

       COLOR_BGR2HSV_FULL = 66,
       COLOR_RGB2HSV_FULL = 67,
       COLOR_BGR2HLS_FULL = 68,
       COLOR_RGB2HLS_FULL = 69,

       COLOR_HSV2BGR_FULL = 70,
       COLOR_HSV2RGB_FULL = 71,
       COLOR_HLS2BGR_FULL = 72,
       COLOR_HLS2RGB_FULL = 73,

       COLOR_LBGR2Lab     = 74,
       COLOR_LRGB2Lab     = 75,
       COLOR_LBGR2Luv     = 76,
       COLOR_LRGB2Luv     = 77,

       COLOR_Lab2LBGR     = 78,
       COLOR_Lab2LRGB     = 79,
       COLOR_Luv2LBGR     = 80,
       COLOR_Luv2LRGB     = 81,

       COLOR_BGR2YUV      = 82,
       COLOR_RGB2YUV      = 83,
       COLOR_YUV2BGR      = 84,
       COLOR_YUV2RGB      = 85,

       // YUV 4:2:0 family to RGB
       COLOR_YUV2RGB_NV12  = 90,
       COLOR_YUV2BGR_NV12  = 91,
       COLOR_YUV2RGB_NV21  = 92,
       COLOR_YUV2BGR_NV21  = 93,
       COLOR_YUV420sp2RGB  = COLOR_YUV2RGB_NV21,
       COLOR_YUV420sp2BGR  = COLOR_YUV2BGR_NV21,

       COLOR_YUV2RGBA_NV12 = 94,
       COLOR_YUV2BGRA_NV12 = 95,
       COLOR_YUV2RGBA_NV21 = 96,
       COLOR_YUV2BGRA_NV21 = 97,
       COLOR_YUV420sp2RGBA = COLOR_YUV2RGBA_NV21,
       COLOR_YUV420sp2BGRA = COLOR_YUV2BGRA_NV21,

       COLOR_YUV2RGB_YV12  = 98,
       COLOR_YUV2BGR_YV12  = 99,
       COLOR_YUV2RGB_IYUV  = 100,
       COLOR_YUV2BGR_IYUV  = 101,
       COLOR_YUV2RGB_I420  = COLOR_YUV2RGB_IYUV,
       COLOR_YUV2BGR_I420  = COLOR_YUV2BGR_IYUV,
       COLOR_YUV420p2RGB   = COLOR_YUV2RGB_YV12,
       COLOR_YUV420p2BGR   = COLOR_YUV2BGR_YV12,

       COLOR_YUV2RGBA_YV12 = 102,
       COLOR_YUV2BGRA_YV12 = 103,
       COLOR_YUV2RGBA_IYUV = 104,
       COLOR_YUV2BGRA_IYUV = 105,
       COLOR_YUV2RGBA_I420 = COLOR_YUV2RGBA_IYUV,
       COLOR_YUV2BGRA_I420 = COLOR_YUV2BGRA_IYUV,
       COLOR_YUV420p2RGBA  = COLOR_YUV2RGBA_YV12,
       COLOR_YUV420p2BGRA  = COLOR_YUV2BGRA_YV12,

       COLOR_YUV2GRAY_420  = 106,
       COLOR_YUV2GRAY_NV21 = COLOR_YUV2GRAY_420,
       COLOR_YUV2GRAY_NV12 = COLOR_YUV2GRAY_420,
       COLOR_YUV2GRAY_YV12 = COLOR_YUV2GRAY_420,
       COLOR_YUV2GRAY_IYUV = COLOR_YUV2GRAY_420,
       COLOR_YUV2GRAY_I420 = COLOR_YUV2GRAY_420,
       COLOR_YUV420sp2GRAY = COLOR_YUV2GRAY_420,
       COLOR_YUV420p2GRAY  = COLOR_YUV2GRAY_420,

       // YUV 4:2:2 family to RGB
       COLOR_YUV2RGB_UYVY = 107,
       COLOR_YUV2BGR_UYVY = 108,
     //COLOR_YUV2RGB_VYUY = 109,
     //COLOR_YUV2BGR_VYUY = 110,
       COLOR_YUV2RGB_Y422 = COLOR_YUV2RGB_UYVY,
       COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY,
       COLOR_YUV2RGB_UYNV = COLOR_YUV2RGB_UYVY,
       COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY,

       COLOR_YUV2RGBA_UYVY = 111,
       COLOR_YUV2BGRA_UYVY = 112,
     //COLOR_YUV2RGBA_VYUY = 113,
     //COLOR_YUV2BGRA_VYUY = 114,
       COLOR_YUV2RGBA_Y422 = COLOR_YUV2RGBA_UYVY,
       COLOR_YUV2BGRA_Y422 = COLOR_YUV2BGRA_UYVY,
       COLOR_YUV2RGBA_UYNV = COLOR_YUV2RGBA_UYVY,
       COLOR_YUV2BGRA_UYNV = COLOR_YUV2BGRA_UYVY,

       COLOR_YUV2RGB_YUY2 = 115,
       COLOR_YUV2BGR_YUY2 = 116,
       COLOR_YUV2RGB_YVYU = 117,
       COLOR_YUV2BGR_YVYU = 118,
       COLOR_YUV2RGB_YUYV = COLOR_YUV2RGB_YUY2,
       COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2,
       COLOR_YUV2RGB_YUNV = COLOR_YUV2RGB_YUY2,
       COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2,

       COLOR_YUV2RGBA_YUY2 = 119,
       COLOR_YUV2BGRA_YUY2 = 120,
       COLOR_YUV2RGBA_YVYU = 121,
       COLOR_YUV2BGRA_YVYU = 122,
       COLOR_YUV2RGBA_YUYV = COLOR_YUV2RGBA_YUY2,
       COLOR_YUV2BGRA_YUYV = COLOR_YUV2BGRA_YUY2,
       COLOR_YUV2RGBA_YUNV = COLOR_YUV2RGBA_YUY2,
       COLOR_YUV2BGRA_YUNV = COLOR_YUV2BGRA_YUY2,

       COLOR_YUV2GRAY_UYVY = 123,
       COLOR_YUV2GRAY_YUY2 = 124,
     //CV_YUV2GRAY_VYUY    = CV_YUV2GRAY_UYVY,
       COLOR_YUV2GRAY_Y422 = COLOR_YUV2GRAY_UYVY,
       COLOR_YUV2GRAY_UYNV = COLOR_YUV2GRAY_UYVY,
       COLOR_YUV2GRAY_YVYU = COLOR_YUV2GRAY_YUY2,
       COLOR_YUV2GRAY_YUYV = COLOR_YUV2GRAY_YUY2,
       COLOR_YUV2GRAY_YUNV = COLOR_YUV2GRAY_YUY2,

       // alpha premultiplication
       COLOR_RGBA2mRGBA    = 125,
       COLOR_mRGBA2RGBA    = 126,

       // RGB to YUV 4:2:0 family
       COLOR_RGB2YUV_I420  = 127,
       COLOR_BGR2YUV_I420  = 128,
       COLOR_RGB2YUV_IYUV  = COLOR_RGB2YUV_I420,
       COLOR_BGR2YUV_IYUV  = COLOR_BGR2YUV_I420,

       COLOR_RGBA2YUV_I420 = 129,
       COLOR_BGRA2YUV_I420 = 130,
       COLOR_RGBA2YUV_IYUV = COLOR_RGBA2YUV_I420,
       COLOR_BGRA2YUV_IYUV = COLOR_BGRA2YUV_I420,
       COLOR_RGB2YUV_YV12  = 131,
       COLOR_BGR2YUV_YV12  = 132,
       COLOR_RGBA2YUV_YV12 = 133,
       COLOR_BGRA2YUV_YV12 = 134,

       // Demosaicing
       COLOR_BayerBG2BGR = 46,
       COLOR_BayerGB2BGR = 47,
       COLOR_BayerRG2BGR = 48,
       COLOR_BayerGR2BGR = 49,

       COLOR_BayerBG2RGB = COLOR_BayerRG2BGR,
       COLOR_BayerGB2RGB = COLOR_BayerGR2BGR,
       COLOR_BayerRG2RGB = COLOR_BayerBG2BGR,
       COLOR_BayerGR2RGB = COLOR_BayerGB2BGR,

       COLOR_BayerBG2GRAY = 86,
       COLOR_BayerGB2GRAY = 87,
       COLOR_BayerRG2GRAY = 88,
       COLOR_BayerGR2GRAY = 89,

       // Demosaicing using Variable Number of Gradients
       COLOR_BayerBG2BGR_VNG = 62,
       COLOR_BayerGB2BGR_VNG = 63,
       COLOR_BayerRG2BGR_VNG = 64,
       COLOR_BayerGR2BGR_VNG = 65,

       COLOR_BayerBG2RGB_VNG = COLOR_BayerRG2BGR_VNG,
       COLOR_BayerGB2RGB_VNG = COLOR_BayerGR2BGR_VNG,
       COLOR_BayerRG2RGB_VNG = COLOR_BayerBG2BGR_VNG,
       COLOR_BayerGR2RGB_VNG = COLOR_BayerGB2BGR_VNG,

       // Edge-Aware Demosaicing
       COLOR_BayerBG2BGR_EA  = 135,
       COLOR_BayerGB2BGR_EA  = 136,
       COLOR_BayerRG2BGR_EA  = 137,
       COLOR_BayerGR2BGR_EA  = 138,

       COLOR_BayerBG2RGB_EA  = COLOR_BayerRG2BGR_EA,
       COLOR_BayerGB2RGB_EA  = COLOR_BayerGR2BGR_EA,
       COLOR_BayerRG2RGB_EA  = COLOR_BayerBG2BGR_EA,
       COLOR_BayerGR2RGB_EA  = COLOR_BayerGB2BGR_EA,


       COLOR_COLORCVT_MAX  = 139
};

//! types of intersection between rectangles
enum { INTERSECT_NONE = 0,
       INTERSECT_PARTIAL  = 1,
       INTERSECT_FULL  = 2
     };

/*!
 The Base Class for 1D or Row-wise Filters

 This is the base class for linear or non-linear filters that process 1D data.
 In particular, such filters are used for the ""horizontal"" filtering parts in separable filters.

 Several functions in OpenCV return Ptr<BaseRowFilter> for the specific types of filters,
 and those pointers can be used directly or within cv::FilterEngine.
*/
class CV_EXPORTS BaseRowFilter
{
public:
    //! the default constructor
    BaseRowFilter();
    //! the destructor
    virtual ~BaseRowFilter();
    //! the filtering operator. Must be overrided in the derived classes. The horizontal border interpolation is done outside of the class.
    virtual void operator()(const uchar* src, uchar* dst, int width, int cn) = 0;

    int ksize;
    int anchor;
};


/*!
 The Base Class for Column-wise Filters

 This is the base class for linear or non-linear filters that process columns of 2D arrays.
 Such filters are used for the ""vertical"" filtering parts in separable filters.

 Several functions in OpenCV return Ptr<BaseColumnFilter> for the specific types of filters,
 and those pointers can be used directly or within cv::FilterEngine.

 Unlike cv::BaseRowFilter, cv::BaseColumnFilter may have some context information,
 i.e. box filter keeps the sliding sum of elements. To reset the state BaseColumnFilter::reset()
 must be called (e.g. the method is called by cv::FilterEngine)
 */
class CV_EXPORTS BaseColumnFilter
{
public:
    //! the default constructor
    BaseColumnFilter();
    //! the destructor
    virtual ~BaseColumnFilter();
    //! the filtering operator. Must be overrided in the derived classes. The vertical border interpolation is done outside of the class.
    virtual void operator()(const uchar** src, uchar* dst, int dststep, int dstcount, int width) = 0;
    //! resets the internal buffers, if any
    virtual void reset();

    int ksize;
    int anchor;
};


/*!
 The Base Class for Non-Separable 2D Filters.

 This is the base class for linear or non-linear 2D filters.

 Several functions in OpenCV return Ptr<BaseFilter> for the specific types of filters,
 and those pointers can be used directly or within cv::FilterEngine.

 Similar to cv::BaseColumnFilter, the class may have some context information,
 that should be reset using BaseFilter::reset() method before processing the new array.
*/
class CV_EXPORTS BaseFilter
{
public:
    //! the default constructor
    BaseFilter();
    //! the destructor
    virtual ~BaseFilter();
    //! the filtering operator. The horizontal and the vertical border interpolation is done outside of the class.
    virtual void operator()(const uchar** src, uchar* dst, int dststep, int dstcount, int width, int cn) = 0;
    //! resets the internal buffers, if any
    virtual void reset();

    Size ksize;
    Point anchor;
};


/*!
 The Main Class for Image Filtering.

 The class can be used to apply an arbitrary filtering operation to an image.
 It contains all the necessary intermediate buffers, it computes extrapolated values
 of the ""virtual"" pixels outside of the image etc.
 Pointers to the initialized cv::FilterEngine instances
 are returned by various OpenCV functions, such as cv::createSeparableLinearFilter(),
 cv::createLinearFilter(), cv::createGaussianFilter(), cv::createDerivFilter(),
 cv::createBoxFilter() and cv::createMorphologyFilter().

 Using the class you can process large images by parts and build complex pipelines
 that include filtering as some of the stages. If all you need is to apply some pre-defined
 filtering operation, you may use cv::filter2D(), cv::erode(), cv::dilate() etc.
 functions that create FilterEngine internally.

 Here is the example on how to use the class to implement Laplacian operator, which is the sum of
 second-order derivatives. More complex variant for different types is implemented in cv::Laplacian().

 \\code
 void laplace_f(const Mat& src, Mat& dst)
 {
     CV_Assert( src.type() == CV_32F );
     // make sure the destination array has the proper size and type
     dst.create(src.size(), src.type());

     // get the derivative and smooth kernels for d2I/dx2.
     // for d2I/dy2 we could use the same kernels, just swapped
     Mat kd, ks;
     getSobelKernels( kd, ks, 2, 0, ksize, false, ktype );

     // let's process 10 source rows at once
     int DELTA = std::min(10, src.rows);
     Ptr<FilterEngine> Fxx = createSeparableLinearFilter(src.type(),
     dst.type(), kd, ks, Point(-1,-1), 0, borderType, borderType, Scalar() );
     Ptr<FilterEngine> Fyy = createSeparableLinearFilter(src.type(),
     dst.type(), ks, kd, Point(-1,-1), 0, borderType, borderType, Scalar() );

     int y = Fxx->start(src), dsty = 0, dy = 0;
     Fyy->start(src);
     const uchar* sptr = src.data + y*src.step;

     // allocate the buffers for the spatial image derivatives;
     // the buffers need to have more than DELTA rows, because at the
     // last iteration the output may take max(kd.rows-1,ks.rows-1)
     // rows more than the input.
     Mat Ixx( DELTA + kd.rows - 1, src.cols, dst.type() );
     Mat Iyy( DELTA + kd.rows - 1, src.cols, dst.type() );

     // inside the loop we always pass DELTA rows to the filter
     // (note that the ""proceed"" method takes care of possibe overflow, since
     // it was given the actual image height in the ""start"" method)
     // on output we can get:
     //  * < DELTA rows (the initial buffer accumulation stage)
     //  * = DELTA rows (settled state in the middle)
     //  * > DELTA rows (then the input image is over, but we generate
     //                  ""virtual"" rows using the border mode and filter them)
     // this variable number of output rows is dy.
     // dsty is the current output row.
     // sptr is the pointer to the first input row in the portion to process
     for( ; dsty < dst.rows; sptr += DELTA*src.step, dsty += dy )
     {
         Fxx->proceed( sptr, (int)src.step, DELTA, Ixx.data, (int)Ixx.step );
         dy = Fyy->proceed( sptr, (int)src.step, DELTA, d2y.data, (int)Iyy.step );
         if( dy > 0 )
         {
             Mat dstripe = dst.rowRange(dsty, dsty + dy);
             add(Ixx.rowRange(0, dy), Iyy.rowRange(0, dy), dstripe);
         }
     }
 }
 \\endcode
*/
class CV_EXPORTS FilterEngine
{
public:
    //! the default constructor
    FilterEngine();
    //! the full constructor. Either _filter2D or both _rowFilter and _columnFilter must be non-empty.
    FilterEngine(const Ptr<BaseFilter>& _filter2D,
                 const Ptr<BaseRowFilter>& _rowFilter,
                 const Ptr<BaseColumnFilter>& _columnFilter,
                 int srcType, int dstType, int bufType,
                 int _rowBorderType = BORDER_REPLICATE,
                 int _columnBorderType = -1,
                 const Scalar& _borderValue = Scalar());
    //! the destructor
    virtual ~FilterEngine();
    //! reinitializes the engine. The previously assigned filters are released.
    void init(const Ptr<BaseFilter>& _filter2D,
              const Ptr<BaseRowFilter>& _rowFilter,
              const Ptr<BaseColumnFilter>& _columnFilter,
              int srcType, int dstType, int bufType,
              int _rowBorderType = BORDER_REPLICATE,
              int _columnBorderType = -1,
              const Scalar& _borderValue = Scalar());
    //! starts filtering of the specified ROI of an image of size wholeSize.
    virtual int start(Size wholeSize, Rect roi, int maxBufRows = -1);
    //! starts filtering of the specified ROI of the specified image.
    virtual int start(const Mat& src, const Rect& srcRoi = Rect(0,0,-1,-1),
                      bool isolated = false, int maxBufRows = -1);
    //! processes the next srcCount rows of the image.
    virtual int proceed(const uchar* src, int srcStep, int srcCount,
                        uchar* dst, int dstStep);
    //! applies filter to the specified ROI of the image. if srcRoi=(0,0,-1,-1), the whole image is filtered.
    virtual void apply( const Mat& src, Mat& dst,
                        const Rect& srcRoi = Rect(0,0,-1,-1),
                        Point dstOfs = Point(0,0),
                        bool isolated = false);
    //! returns true if the filter is separable
    bool isSeparable() const { return !filter2D; }
    //! returns the number
    int remainingInputRows() const;
    int remainingOutputRows() const;

    int srcType;
    int dstType;
    int bufType;
    Size ksize;
    Point anchor;
    int maxWidth;
    Size wholeSize;
    Rect roi;
    int dx1;
    int dx2;
    int rowBorderType;
    int columnBorderType;
    std::vector<int> borderTab;
    int borderElemSize;
    std::vector<uchar> ringBuf;
    std::vector<uchar> srcRow;
    std::vector<uchar> constBorderValue;
    std::vector<uchar> constBorderRow;
    int bufStep;
    int startY;
    int startY0;
    int endY;
    int rowCount;
    int dstY;
    std::vector<uchar*> rows;

    Ptr<BaseFilter> filter2D;
    Ptr<BaseRowFilter> rowFilter;
    Ptr<BaseColumnFilter> columnFilter;
};


//! finds arbitrary template in the grayscale image using Generalized Hough Transform
class CV_EXPORTS GeneralizedHough : public Algorithm
{
public:
    //! set template to search
    virtual void setTemplate(InputArray templ, Point templCenter = Point(-1, -1)) = 0;
    virtual void setTemplate(InputArray edges, InputArray dx, InputArray dy, Point templCenter = Point(-1, -1)) = 0;

    //! find template on image
    virtual void detect(InputArray image, OutputArray positions, OutputArray votes = noArray()) = 0;
    virtual void detect(InputArray edges, InputArray dx, InputArray dy, OutputArray positions, OutputArray votes = noArray()) = 0;

    //! Canny low threshold.
    virtual void setCannyLowThresh(int cannyLowThresh) = 0;
    virtual int getCannyLowThresh() const = 0;

    //! Canny high threshold.
    virtual void setCannyHighThresh(int cannyHighThresh) = 0;
    virtual int getCannyHighThresh() const = 0;

    //! Minimum distance between the centers of the detected objects.
    virtual void setMinDist(double minDist) = 0;
    virtual double getMinDist() const = 0;

    //! Inverse ratio of the accumulator resolution to the image resolution.
    virtual void setDp(double dp) = 0;
    virtual double getDp() const = 0;

    //! Maximal size of inner buffers.
    virtual void setMaxBufferSize(int maxBufferSize) = 0;
    virtual int getMaxBufferSize() const = 0;
};

//! Ballard, D.H. (1981). Generalizing the Hough transform to detect arbitrary shapes. Pattern Recognition 13 (2): 111-122.
//! Detects position only without traslation and rotation
class CV_EXPORTS GeneralizedHoughBallard : public GeneralizedHough
{
public:
    //! R-Table levels.
    virtual void setLevels(int levels) = 0;
    virtual int getLevels() const = 0;

    //! The accumulator threshold for the template centers at the detection stage. The smaller it is, the more false positions may be detected.
    virtual void setVotesThreshold(int votesThreshold) = 0;
    virtual int getVotesThreshold() const = 0;
};

//! Guil, N., González-Linares, J.M. and Zapata, E.L. (1999). Bidimensional shape detection using an invariant approach. Pattern Recognition 32 (6): 1025-1038.
//! Detects position, traslation and rotation
class CV_EXPORTS GeneralizedHoughGuil : public GeneralizedHough
{
public:
    //! Angle difference in degrees between two points in feature.
    virtual void setXi(double xi) = 0;
    virtual double getXi() const = 0;

    //! Feature table levels.
    virtual void setLevels(int levels) = 0;
    virtual int getLevels() const = 0;

    //! Maximal difference between angles that treated as equal.
    virtual void setAngleEpsilon(double angleEpsilon) = 0;
    virtual double getAngleEpsilon() const = 0;

    //! Minimal rotation angle to detect in degrees.
    virtual void setMinAngle(double minAngle) = 0;
    virtual double getMinAngle() const = 0;

    //! Maximal rotation angle to detect in degrees.
    virtual void setMaxAngle(double maxAngle) = 0;
    virtual double getMaxAngle() const = 0;

    //! Angle step in degrees.
    virtual void setAngleStep(double angleStep) = 0;
    virtual double getAngleStep() const = 0;

    //! Angle votes threshold.
    virtual void setAngleThresh(int angleThresh) = 0;
    virtual int getAngleThresh() const = 0;

    //! Minimal scale to detect.
    virtual void setMinScale(double minScale) = 0;
    virtual double getMinScale() const = 0;

    //! Maximal scale to detect.
    virtual void setMaxScale(double maxScale) = 0;
    virtual double getMaxScale() const = 0;

    //! Scale step.
    virtual void setScaleStep(double scaleStep) = 0;
    virtual double getScaleStep() const = 0;

    //! Scale votes threshold.
    virtual void setScaleThresh(int scaleThresh) = 0;
    virtual int getScaleThresh() const = 0;

    //! Position votes threshold.
    virtual void setPosThresh(int posThresh) = 0;
    virtual int getPosThresh() const = 0;
};


class CV_EXPORTS_W CLAHE : public Algorithm
{
public:
    CV_WRAP virtual void apply(InputArray src, OutputArray dst) = 0;

    CV_WRAP virtual void setClipLimit(double clipLimit) = 0;
    CV_WRAP virtual double getClipLimit() const = 0;

    CV_WRAP virtual void setTilesGridSize(Size tileGridSize) = 0;
    CV_WRAP virtual Size getTilesGridSize() const = 0;

    CV_WRAP virtual void collectGarbage() = 0;
};


class CV_EXPORTS_W Subdiv2D
{
public:
    enum { PTLOC_ERROR        = -2,
           PTLOC_OUTSIDE_RECT = -1,
           PTLOC_INSIDE       = 0,
           PTLOC_VERTEX       = 1,
           PTLOC_ON_EDGE      = 2
         };

    enum { NEXT_AROUND_ORG   = 0x00,
           NEXT_AROUND_DST   = 0x22,
           PREV_AROUND_ORG   = 0x11,
           PREV_AROUND_DST   = 0x33,
           NEXT_AROUND_LEFT  = 0x13,
           NEXT_AROUND_RIGHT = 0x31,
           PREV_AROUND_LEFT  = 0x20,
           PREV_AROUND_RIGHT = 0x02
         };

    CV_WRAP Subdiv2D();
    CV_WRAP Subdiv2D(Rect rect);
    CV_WRAP void initDelaunay(Rect rect);

    CV_WRAP int insert(Point2f pt);
    CV_WRAP void insert(const std::vector<Point2f>& ptvec);
    CV_WRAP int locate(Point2f pt, CV_OUT int& edge, CV_OUT int& vertex);

    CV_WRAP int findNearest(Point2f pt, CV_OUT Point2f* nearestPt = 0);
    CV_WRAP void getEdgeList(CV_OUT std::vector<Vec4f>& edgeList) const;
    CV_WRAP void getTriangleList(CV_OUT std::vector<Vec6f>& triangleList) const;
    CV_WRAP void getVoronoiFacetList(const std::vector<int>& idx, CV_OUT std::vector<std::vector<Point2f> >& facetList,
                                     CV_OUT std::vector<Point2f>& facetCenters);

    CV_WRAP Point2f getVertex(int vertex, CV_OUT int* firstEdge = 0) const;

    CV_WRAP int getEdge( int edge, int nextEdgeType ) const;
    CV_WRAP int nextEdge(int edge) const;
    CV_WRAP int rotateEdge(int edge, int rotate) const;
    CV_WRAP int symEdge(int edge) const;
    CV_WRAP int edgeOrg(int edge, CV_OUT Point2f* orgpt = 0) const;
    CV_WRAP int edgeDst(int edge, CV_OUT Point2f* dstpt = 0) const;

protected:
    int newEdge();
    void deleteEdge(int edge);
    int newPoint(Point2f pt, bool isvirtual, int firstEdge = 0);
    void deletePoint(int vtx);
    void setEdgePoints( int edge, int orgPt, int dstPt );
    void splice( int edgeA, int edgeB );
    int connectEdges( int edgeA, int edgeB );
    void swapEdges( int edge );
    int isRightOf(Point2f pt, int edge) const;
    void calcVoronoi();
    void clearVoronoi();
    void checkSubdiv() const;

    struct CV_EXPORTS Vertex
    {
        Vertex();
        Vertex(Point2f pt, bool _isvirtual, int _firstEdge=0);
        bool isvirtual() const;
        bool isfree() const;

        int firstEdge;
        int type;
        Point2f pt;
    };

    struct CV_EXPORTS QuadEdge
    {
        QuadEdge();
        QuadEdge(int edgeidx);
        bool isfree() const;

        int next[4];
        int pt[4];
    };

    std::vector<Vertex> vtx;
    std::vector<QuadEdge> qedges;
    int freeQEdge;
    int freePoint;
    bool validGeometry;

    int recentEdge;
    Point2f topLeft;
    Point2f bottomRight;
};

class CV_EXPORTS_W LineSegmentDetector : public Algorithm
{
public:
/**
 * Detect lines in the input image.
 *
 * @param _image    A grayscale(CV_8UC1) input image.
 *                  If only a roi needs to be selected, use
 *                  lsd_ptr->detect(image(roi), ..., lines);
 *                  lines += Scalar(roi.x, roi.y, roi.x, roi.y);
 * @param _lines    Return: A vector of Vec4i elements specifying the beginning and ending point of a line.
 *                          Where Vec4i is (x1, y1, x2, y2), point 1 is the start, point 2 - end.
 *                          Returned lines are strictly oriented depending on the gradient.
 * @param width     Return: Vector of widths of the regions, where the lines are found. E.g. Width of line.
 * @param prec      Return: Vector of precisions with which the lines are found.
 * @param nfa       Return: Vector containing number of false alarms in the line region, with precision of 10%.
 *                          The bigger the value, logarithmically better the detection.
 *                              * -1 corresponds to 10 mean false alarms
 *                              * 0 corresponds to 1 mean false alarm
 *                              * 1 corresponds to 0.1 mean false alarms
 *                          This vector will be calculated _only_ when the objects type is REFINE_ADV
 */
    CV_WRAP virtual void detect(InputArray _image, OutputArray _lines,
                        OutputArray width = noArray(), OutputArray prec = noArray(),
                        OutputArray nfa = noArray()) = 0;

/**
 * Draw lines on the given canvas.
 *
 * @param image     The image, where lines will be drawn.
 *                  Should have the size of the image, where the lines were found
 * @param lines     The lines that need to be drawn
 */
    CV_WRAP virtual void drawSegments(InputOutputArray _image, InputArray lines) = 0;

/**
 * Draw both vectors on the image canvas. Uses blue for lines 1 and red for lines 2.
 *
 * @param size      The size of the image, where lines were found.
 * @param lines1    The first lines that need to be drawn. Color - Blue.
 * @param lines2    The second lines that need to be drawn. Color - Red.
 * @param image     Optional image, where lines will be drawn.
 *                  Should have the size of the image, where the lines were found
 * @return          The number of mismatching pixels between lines1 and lines2.
 */
    CV_WRAP virtual int compareSegments(const Size& size, InputArray lines1, InputArray lines2, InputOutputArray _image = noArray()) = 0;

    virtual ~LineSegmentDetector() { }
};

//! Returns a pointer to a LineSegmentDetector class.
CV_EXPORTS_W Ptr<LineSegmentDetector> createLineSegmentDetector(
    int _refine = LSD_REFINE_STD, double _scale = 0.8,
    double _sigma_scale = 0.6, double _quant = 2.0, double _ang_th = 22.5,
    double _log_eps = 0, double _density_th = 0.7, int _n_bins = 1024);

//! returns type (one of KERNEL_*) of 1D or 2D kernel specified by its coefficients.
CV_EXPORTS int getKernelType(InputArray kernel, Point anchor);

//! returns the primitive row filter with the specified kernel
CV_EXPORTS Ptr<BaseRowFilter> getLinearRowFilter(int srcType, int bufType,
                                            InputArray kernel, int anchor,
                                            int symmetryType);

//! returns the primitive column filter with the specified kernel
CV_EXPORTS Ptr<BaseColumnFilter> getLinearColumnFilter(int bufType, int dstType,
                                            InputArray kernel, int anchor,
                                            int symmetryType, double delta = 0,
                                            int bits = 0);

//! returns 2D filter with the specified kernel
CV_EXPORTS Ptr<BaseFilter> getLinearFilter(int srcType, int dstType,
                                           InputArray kernel,
                                           Point anchor = Point(-1,-1),
                                           double delta = 0, int bits = 0);

//! returns the separable linear filter engine
CV_EXPORTS Ptr<FilterEngine> createSeparableLinearFilter(int srcType, int dstType,
                          InputArray rowKernel, InputArray columnKernel,
                          Point anchor = Point(-1,-1), double delta = 0,
                          int rowBorderType = BORDER_DEFAULT,
                          int columnBorderType = -1,
                          const Scalar& borderValue = Scalar());

//! returns the non-separable linear filter engine
CV_EXPORTS Ptr<FilterEngine> createLinearFilter(int srcType, int dstType,
                 InputArray kernel, Point _anchor = Point(-1,-1),
                 double delta = 0, int rowBorderType = BORDER_DEFAULT,
                 int columnBorderType = -1, const Scalar& borderValue = Scalar());

//! returns the Gaussian kernel with the specified parameters
CV_EXPORTS_W Mat getGaussianKernel( int ksize, double sigma, int ktype = CV_64F );

//! returns the Gaussian filter engine
CV_EXPORTS Ptr<FilterEngine> createGaussianFilter( int type, Size ksize,
                                    double sigma1, double sigma2 = 0,
                                    int borderType = BORDER_DEFAULT);

//! initializes kernels of the generalized Sobel operator
CV_EXPORTS_W void getDerivKernels( OutputArray kx, OutputArray ky,
                                   int dx, int dy, int ksize,
                                   bool normalize = false, int ktype = CV_32F );

//! returns filter engine for the generalized Sobel operator
CV_EXPORTS Ptr<FilterEngine> createDerivFilter( int srcType, int dstType,
                                        int dx, int dy, int ksize,
                                        int borderType = BORDER_DEFAULT );

//! returns horizontal 1D box filter
CV_EXPORTS Ptr<BaseRowFilter> getRowSumFilter(int srcType, int sumType,
                                              int ksize, int anchor = -1);

//! returns vertical 1D box filter
CV_EXPORTS Ptr<BaseColumnFilter> getColumnSumFilter( int sumType, int dstType,
                                                     int ksize, int anchor = -1,
                                                     double scale = 1);
//! returns box filter engine
CV_EXPORTS Ptr<FilterEngine> createBoxFilter( int srcType, int dstType, Size ksize,
                                              Point anchor = Point(-1,-1),
                                              bool normalize = true,
                                              int borderType = BORDER_DEFAULT);

//! returns the Gabor kernel with the specified parameters
CV_EXPORTS_W Mat getGaborKernel( Size ksize, double sigma, double theta, double lambd,
                                 double gamma, double psi = CV_PI*0.5, int ktype = CV_64F );

//! returns horizontal 1D morphological filter
CV_EXPORTS Ptr<BaseRowFilter> getMorphologyRowFilter(int op, int type, int ksize, int anchor = -1);

//! returns vertical 1D morphological filter
CV_EXPORTS Ptr<BaseColumnFilter> getMorphologyColumnFilter(int op, int type, int ksize, int anchor = -1);

//! returns 2D morphological filter
CV_EXPORTS Ptr<BaseFilter> getMorphologyFilter(int op, int type, InputArray kernel,
                                               Point anchor = Point(-1,-1));

//! returns ""magic"" border value for erosion and dilation. It is automatically transformed to Scalar::all(-DBL_MAX) for dilation.
static inline Scalar morphologyDefaultBorderValue() { return Scalar::all(DBL_MAX); }

//! returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported.
CV_EXPORTS Ptr<FilterEngine> createMorphologyFilter(int op, int type, InputArray kernel,
                    Point anchor = Point(-1,-1), int rowBorderType = BORDER_CONSTANT,
                    int columnBorderType = -1, const Scalar& borderValue = morphologyDefaultBorderValue());

//! returns structuring element of the specified shape and size
CV_EXPORTS_W Mat getStructuringElement(int shape, Size ksize, Point anchor = Point(-1,-1));

//! smooths the image using median filter.
CV_EXPORTS_W void medianBlur( InputArray src, OutputArray dst, int ksize );

//! smooths the image using Gaussian filter.
CV_EXPORTS_W void GaussianBlur( InputArray src, OutputArray dst, Size ksize,
                                double sigmaX, double sigmaY = 0,
                                int borderType = BORDER_DEFAULT );

//! smooths the image using bilateral filter
CV_EXPORTS_W void bilateralFilter( InputArray src, OutputArray dst, int d,
                                   double sigmaColor, double sigmaSpace,
                                   int borderType = BORDER_DEFAULT );

//! smooths the image using the box filter. Each pixel is processed in O(1) time
CV_EXPORTS_W void boxFilter( InputArray src, OutputArray dst, int ddepth,
                             Size ksize, Point anchor = Point(-1,-1),
                             bool normalize = true,
                             int borderType = BORDER_DEFAULT );

CV_EXPORTS_W void sqrBoxFilter( InputArray _src, OutputArray _dst, int ddepth,
                                Size ksize, Point anchor = Point(-1, -1),
                                bool normalize = true,
                                int borderType = BORDER_DEFAULT );

//! a synonym for normalized box filter
CV_EXPORTS_W void blur( InputArray src, OutputArray dst,
                        Size ksize, Point anchor = Point(-1,-1),
                        int borderType = BORDER_DEFAULT );

//! applies non-separable 2D linear filter to the image
CV_EXPORTS_W void filter2D( InputArray src, OutputArray dst, int ddepth,
                            InputArray kernel, Point anchor = Point(-1,-1),
                            double delta = 0, int borderType = BORDER_DEFAULT );

//! applies separable 2D linear filter to the image
CV_EXPORTS_W void sepFilter2D( InputArray src, OutputArray dst, int ddepth,
                               InputArray kernelX, InputArray kernelY,
                               Point anchor = Point(-1,-1),
                               double delta = 0, int borderType = BORDER_DEFAULT );

//! applies generalized Sobel operator to the image
CV_EXPORTS_W void Sobel( InputArray src, OutputArray dst, int ddepth,
                         int dx, int dy, int ksize = 3,
                         double scale = 1, double delta = 0,
                         int borderType = BORDER_DEFAULT );

//! applies the vertical or horizontal Scharr operator to the image
CV_EXPORTS_W void Scharr( InputArray src, OutputArray dst, int ddepth,
                          int dx, int dy, double scale = 1, double delta = 0,
                          int borderType = BORDER_DEFAULT );

//! applies Laplacian operator to the image
CV_EXPORTS_W void Laplacian( InputArray src, OutputArray dst, int ddepth,
                             int ksize = 1, double scale = 1, double delta = 0,
                             int borderType = BORDER_DEFAULT );

//! applies Canny edge detector and produces the edge map.
CV_EXPORTS_W void Canny( InputArray image, OutputArray edges,
                         double threshold1, double threshold2,
                         int apertureSize = 3, bool L2gradient = false );

//! computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria
CV_EXPORTS_W void cornerMinEigenVal( InputArray src, OutputArray dst,
                                     int blockSize, int ksize = 3,
                                     int borderType = BORDER_DEFAULT );

//! computes Harris cornerness criteria at each image pixel
CV_EXPORTS_W void cornerHarris( InputArray src, OutputArray dst, int blockSize,
                                int ksize, double k,
                                int borderType = BORDER_DEFAULT );

//! computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix  at each pixel. The output is stored as 6-channel matrix.
CV_EXPORTS_W void cornerEigenValsAndVecs( InputArray src, OutputArray dst,
                                          int blockSize, int ksize,
                                          int borderType = BORDER_DEFAULT );

//! computes another complex cornerness criteria at each pixel
CV_EXPORTS_W void preCornerDetect( InputArray src, OutputArray dst, int ksize,
                                   int borderType = BORDER_DEFAULT );

//! adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria
CV_EXPORTS_W void cornerSubPix( InputArray image, InputOutputArray corners,
                                Size winSize, Size zeroZone,
                                TermCriteria criteria );

//! finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima
CV_EXPORTS_W void goodFeaturesToTrack( InputArray image, OutputArray corners,
                                     int maxCorners, double qualityLevel, double minDistance,
                                     InputArray mask = noArray(), int blockSize = 3,
                                     bool useHarrisDetector = false, double k = 0.04 );

//! finds lines in the black-n-white image using the standard or pyramid Hough transform
CV_EXPORTS_W void HoughLines( InputArray image, OutputArray lines,
                              double rho, double theta, int threshold,
                              double srn = 0, double stn = 0,
                              double min_theta = 0, double max_theta = CV_PI );

//! finds line segments in the black-n-white image using probabilistic Hough transform
CV_EXPORTS_W void HoughLinesP( InputArray image, OutputArray lines,
                               double rho, double theta, int threshold,
                               double minLineLength = 0, double maxLineGap = 0 );

//! finds circles in the grayscale image using 2+1 gradient Hough transform
CV_EXPORTS_W void HoughCircles( InputArray image, OutputArray circles,
                               int method, double dp, double minDist,
                               double param1 = 100, double param2 = 100,
                               int minRadius = 0, int maxRadius = 0 );

//! erodes the image (applies the local minimum operator)
CV_EXPORTS_W void erode( InputArray src, OutputArray dst, InputArray kernel,
                         Point anchor = Point(-1,-1), int iterations = 1,
                         int borderType = BORDER_CONSTANT,
                         const Scalar& borderValue = morphologyDefaultBorderValue() );

//! dilates the image (applies the local maximum operator)
CV_EXPORTS_W void dilate( InputArray src, OutputArray dst, InputArray kernel,
                          Point anchor = Point(-1,-1), int iterations = 1,
                          int borderType = BORDER_CONSTANT,
                          const Scalar& borderValue = morphologyDefaultBorderValue() );

//! applies an advanced morphological operation to the image
CV_EXPORTS_W void morphologyEx( InputArray src, OutputArray dst,
                                int op, InputArray kernel,
                                Point anchor = Point(-1,-1), int iterations = 1,
                                int borderType = BORDER_CONSTANT,
                                const Scalar& borderValue = morphologyDefaultBorderValue() );

//! resizes the image
CV_EXPORTS_W void resize( InputArray src, OutputArray dst,
                          Size dsize, double fx = 0, double fy = 0,
                          int interpolation = INTER_LINEAR );

//! warps the image using affine transformation
CV_EXPORTS_W void warpAffine( InputArray src, OutputArray dst,
                              InputArray M, Size dsize,
                              int flags = INTER_LINEAR,
                              int borderMode = BORDER_CONSTANT,
                              const Scalar& borderValue = Scalar());

//! warps the image using perspective transformation
CV_EXPORTS_W void warpPerspective( InputArray src, OutputArray dst,
                                   InputArray M, Size dsize,
                                   int flags = INTER_LINEAR,
                                   int borderMode = BORDER_CONSTANT,
                                   const Scalar& borderValue = Scalar());

//! warps the image using the precomputed maps. The maps are stored in either floating-point or integer fixed-point format
CV_EXPORTS_W void remap( InputArray src, OutputArray dst,
                         InputArray map1, InputArray map2,
                         int interpolation, int borderMode = BORDER_CONSTANT,
                         const Scalar& borderValue = Scalar());

//! converts maps for remap from floating-point to fixed-point format or backwards
CV_EXPORTS_W void convertMaps( InputArray map1, InputArray map2,
                               OutputArray dstmap1, OutputArray dstmap2,
                               int dstmap1type, bool nninterpolation = false );

//! returns 2x3 affine transformation matrix for the planar rotation.
CV_EXPORTS_W Mat getRotationMatrix2D( Point2f center, double angle, double scale );

//! returns 3x3 perspective transformation for the corresponding 4 point pairs.
CV_EXPORTS Mat getPerspectiveTransform( const Point2f src[], const Point2f dst[] );

//! returns 2x3 affine transformation for the corresponding 3 point pairs.
CV_EXPORTS Mat getAffineTransform( const Point2f src[], const Point2f dst[] );

//! computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation.
CV_EXPORTS_W void invertAffineTransform( InputArray M, OutputArray iM );

CV_EXPORTS_W Mat getPerspectiveTransform( InputArray src, InputArray dst );

CV_EXPORTS_W Mat getAffineTransform( InputArray src, InputArray dst );

//! extracts rectangle from the image at sub-pixel location
CV_EXPORTS_W void getRectSubPix( InputArray image, Size patchSize,
                                 Point2f center, OutputArray patch, int patchType = -1 );

//! computes the log polar transform
CV_EXPORTS_W void logPolar( InputArray src, OutputArray dst,
                            Point2f center, double M, int flags );

//! computes the linear polar transform
CV_EXPORTS_W void linearPolar( InputArray src, OutputArray dst,
                               Point2f center, double maxRadius, int flags );

//! computes the integral image
CV_EXPORTS_W void integral( InputArray src, OutputArray sum, int sdepth = -1 );

//! computes the integral image and integral for the squared image
CV_EXPORTS_AS(integral2) void integral( InputArray src, OutputArray sum,
                                        OutputArray sqsum, int sdepth = -1, int sqdepth = -1 );

//! computes the integral image, integral for the squared image and the tilted integral image
CV_EXPORTS_AS(integral3) void integral( InputArray src, OutputArray sum,
                                        OutputArray sqsum, OutputArray tilted,
                                        int sdepth = -1, int sqdepth = -1 );

//! adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types.
CV_EXPORTS_W void accumulate( InputArray src, InputOutputArray dst,
                              InputArray mask = noArray() );

//! adds squared src image to the accumulator (dst += src*src).
CV_EXPORTS_W void accumulateSquare( InputArray src, InputOutputArray dst,
                                    InputArray mask = noArray() );
//! adds product of the 2 images to the accumulator (dst += src1*src2).
CV_EXPORTS_W void accumulateProduct( InputArray src1, InputArray src2,
                                     InputOutputArray dst, InputArray mask=noArray() );

//! updates the running average (dst = dst*(1-alpha) + src*alpha)
CV_EXPORTS_W void accumulateWeighted( InputArray src, InputOutputArray dst,
                                      double alpha, InputArray mask = noArray() );

CV_EXPORTS_W Point2d phaseCorrelate(InputArray src1, InputArray src2,
                                    InputArray window = noArray(), CV_OUT double* response = 0);

CV_EXPORTS_W void createHanningWindow(OutputArray dst, Size winSize, int type);

//! applies fixed threshold to the image
CV_EXPORTS_W double threshold( InputArray src, OutputArray dst,
                               double thresh, double maxval, int type );


//! applies variable (adaptive) threshold to the image
CV_EXPORTS_W void adaptiveThreshold( InputArray src, OutputArray dst,
                                     double maxValue, int adaptiveMethod,
                                     int thresholdType, int blockSize, double C );

//! smooths and downsamples the image
CV_EXPORTS_W void pyrDown( InputArray src, OutputArray dst,
                           const Size& dstsize = Size(), int borderType = BORDER_DEFAULT );

//! upsamples and smoothes the image
CV_EXPORTS_W void pyrUp( InputArray src, OutputArray dst,
                         const Size& dstsize = Size(), int borderType = BORDER_DEFAULT );

//! builds the gaussian pyramid using pyrDown() as a basic operation
CV_EXPORTS void buildPyramid( InputArray src, OutputArrayOfArrays dst,
                              int maxlevel, int borderType = BORDER_DEFAULT );

//! corrects lens distortion for the given camera matrix and distortion coefficients
CV_EXPORTS_W void undistort( InputArray src, OutputArray dst,
                             InputArray cameraMatrix,
                             InputArray distCoeffs,
                             InputArray newCameraMatrix = noArray() );

//! initializes maps for cv::remap() to correct lens distortion and optionally rectify the image
CV_EXPORTS_W void initUndistortRectifyMap( InputArray cameraMatrix, InputArray distCoeffs,
                           InputArray R, InputArray newCameraMatrix,
                           Size size, int m1type, OutputArray map1, OutputArray map2 );

//! initializes maps for cv::remap() for wide-angle
CV_EXPORTS_W float initWideAngleProjMap( InputArray cameraMatrix, InputArray distCoeffs,
                                         Size imageSize, int destImageWidth,
                                         int m1type, OutputArray map1, OutputArray map2,
                                         int projType = PROJ_SPHERICAL_EQRECT, double alpha = 0);

//! returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true)
CV_EXPORTS_W Mat getDefaultNewCameraMatrix( InputArray cameraMatrix, Size imgsize = Size(),
                                            bool centerPrincipalPoint = false );

//! returns points' coordinates after lens distortion correction
CV_EXPORTS_W void undistortPoints( InputArray src, OutputArray dst,
                                   InputArray cameraMatrix, InputArray distCoeffs,
                                   InputArray R = noArray(), InputArray P = noArray());

//! computes the joint dense histogram for a set of images.
CV_EXPORTS void calcHist( const Mat* images, int nimages,
                          const int* channels, InputArray mask,
                          OutputArray hist, int dims, const int* histSize,
                          const float** ranges, bool uniform = true, bool accumulate = false );

//! computes the joint sparse histogram for a set of images.
CV_EXPORTS void calcHist( const Mat* images, int nimages,
                          const int* channels, InputArray mask,
                          SparseMat& hist, int dims,
                          const int* histSize, const float** ranges,
                          bool uniform = true, bool accumulate = false );

CV_EXPORTS_W void calcHist( InputArrayOfArrays images,
                            const std::vector<int>& channels,
                            InputArray mask, OutputArray hist,
                            const std::vector<int>& histSize,
                            const std::vector<float>& ranges,
                            bool accumulate = false );

//! computes back projection for the set of images
CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
                                 const int* channels, InputArray hist,
                                 OutputArray backProject, const float** ranges,
                                 double scale = 1, bool uniform = true );

//! computes back projection for the set of images
CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
                                 const int* channels, const SparseMat& hist,
                                 OutputArray backProject, const float** ranges,
                                 double scale = 1, bool uniform = true );

CV_EXPORTS_W void calcBackProject( InputArrayOfArrays images, const std::vector<int>& channels,
                                   InputArray hist, OutputArray dst,
                                   const std::vector<float>& ranges,
                                   double scale );

//! compares two histograms stored in dense arrays
CV_EXPORTS_W double compareHist( InputArray H1, InputArray H2, int method );

//! compares two histograms stored in sparse arrays
CV_EXPORTS double compareHist( const SparseMat& H1, const SparseMat& H2, int method );

//! normalizes the grayscale image brightness and contrast by normalizing its histogram
CV_EXPORTS_W void equalizeHist( InputArray src, OutputArray dst );

CV_EXPORTS float EMD( InputArray signature1, InputArray signature2,
                      int distType, InputArray cost=noArray(),
                      float* lowerBound = 0, OutputArray flow = noArray() );

//! segments the image using watershed algorithm
CV_EXPORTS_W void watershed( InputArray image, InputOutputArray markers );

//! filters image using meanshift algorithm
CV_EXPORTS_W void pyrMeanShiftFiltering( InputArray src, OutputArray dst,
                                         double sp, double sr, int maxLevel = 1,
                                         TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5,1) );

//! segments the image using GrabCut algorithm
CV_EXPORTS_W void grabCut( InputArray img, InputOutputArray mask, Rect rect,
                           InputOutputArray bgdModel, InputOutputArray fgdModel,
                           int iterCount, int mode = GC_EVAL );


//! builds the discrete Voronoi diagram
CV_EXPORTS_AS(distanceTransformWithLabels) void distanceTransform( InputArray src, OutputArray dst,
                                     OutputArray labels, int distanceType, int maskSize,
                                     int labelType = DIST_LABEL_CCOMP );

//! computes the distance transform map
CV_EXPORTS_W void distanceTransform( InputArray src, OutputArray dst,
                                     int distanceType, int maskSize, int dstType=CV_32F);


//! fills the semi-uniform image region starting from the specified seed point
CV_EXPORTS int floodFill( InputOutputArray image,
                          Point seedPoint, Scalar newVal, CV_OUT Rect* rect = 0,
                          Scalar loDiff = Scalar(), Scalar upDiff = Scalar(),
                          int flags = 4 );

//! fills the semi-uniform image region and/or the mask starting from the specified seed point
CV_EXPORTS_W int floodFill( InputOutputArray image, InputOutputArray mask,
                            Point seedPoint, Scalar newVal, CV_OUT Rect* rect=0,
                            Scalar loDiff = Scalar(), Scalar upDiff = Scalar(),
                            int flags = 4 );

//! converts image from one color space to another
CV_EXPORTS_W void cvtColor( InputArray src, OutputArray dst, int code, int dstCn = 0 );

// main function for all demosaicing procceses
CV_EXPORTS_W void demosaicing(InputArray _src, OutputArray _dst, int code, int dcn = 0);

//! computes moments of the rasterized shape or a vector of points
CV_EXPORTS_W Moments moments( InputArray array, bool binaryImage = false );

//! computes 7 Hu invariants from the moments
CV_EXPORTS void HuMoments( const Moments& moments, double hu[7] );

CV_EXPORTS_W void HuMoments( const Moments& m, OutputArray hu );

//! computes the proximity map for the raster template and the image where the template is searched for
CV_EXPORTS_W void matchTemplate( InputArray image, InputArray templ,
                                 OutputArray result, int method );


// computes the connected components labeled image of boolean image ``image``
// with 4 or 8 way connectivity - returns N, the total
// number of labels [0, N-1] where 0 represents the background label.
// ltype specifies the output label image type, an important
// consideration based on the total number of labels or
// alternatively the total number of pixels in the source image.
CV_EXPORTS_W int connectedComponents(InputArray image, OutputArray labels,
                                     int connectivity = 8, int ltype = CV_32S);

CV_EXPORTS_W int connectedComponentsWithStats(InputArray image, OutputArray labels,
                                              OutputArray stats, OutputArray centroids,
                                              int connectivity = 8, int ltype = CV_32S);


//! retrieves contours and the hierarchical information from black-n-white image.
CV_EXPORTS_W void findContours( InputOutputArray image, OutputArrayOfArrays contours,
                              OutputArray hierarchy, int mode,
                              int method, Point offset = Point());

//! retrieves contours from black-n-white image.
CV_EXPORTS void findContours( InputOutputArray image, OutputArrayOfArrays contours,
                              int mode, int method, Point offset = Point());

//! approximates contour or a curve using Douglas-Peucker algorithm
CV_EXPORTS_W void approxPolyDP( InputArray curve,
                                OutputArray approxCurve,
                                double epsilon, bool closed );

//! computes the contour perimeter (closed=true) or a curve length
CV_EXPORTS_W double arcLength( InputArray curve, bool closed );

//! computes the bounding rectangle for a contour
CV_EXPORTS_W Rect boundingRect( InputArray points );

//! computes the contour area
CV_EXPORTS_W double contourArea( InputArray contour, bool oriented = false );

//! computes the minimal rotated rectangle for a set of points
CV_EXPORTS_W RotatedRect minAreaRect( InputArray points );

//! computes boxpoints
CV_EXPORTS_W void boxPoints(RotatedRect box, OutputArray points);

//! computes the minimal enclosing circle for a set of points
CV_EXPORTS_W void minEnclosingCircle( InputArray points,
                                      CV_OUT Point2f& center, CV_OUT float& radius );

//! computes the minimal enclosing triangle for a set of points and returns its area
CV_EXPORTS_W double minEnclosingTriangle( InputArray points, CV_OUT OutputArray triangle );

//! matches two contours using one of the available algorithms
CV_EXPORTS_W double matchShapes( InputArray contour1, InputArray contour2,
                                 int method, double parameter );

//! computes convex hull for a set of 2D points.
CV_EXPORTS_W void convexHull( InputArray points, OutputArray hull,
                              bool clockwise = false, bool returnPoints = true );

//! computes the contour convexity defects
CV_EXPORTS_W void convexityDefects( InputArray contour, InputArray convexhull, OutputArray convexityDefects );

//! returns true if the contour is convex. Does not support contours with self-intersection
CV_EXPORTS_W bool isContourConvex( InputArray contour );

//! finds intersection of two convex polygons
CV_EXPORTS_W float intersectConvexConvex( InputArray _p1, InputArray _p2,
                                          OutputArray _p12, bool handleNested = true );

//! fits ellipse to the set of 2D points
CV_EXPORTS_W RotatedRect fitEllipse( InputArray points );

//! fits line to the set of 2D points using M-estimator algorithm
CV_EXPORTS_W void fitLine( InputArray points, OutputArray line, int distType,
                           double param, double reps, double aeps );

//! checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary
CV_EXPORTS_W double pointPolygonTest( InputArray contour, Point2f pt, bool measureDist );

//! computes whether two rotated rectangles intersect and returns the vertices of the intersecting region
CV_EXPORTS_W int rotatedRectangleIntersection( const RotatedRect& rect1, const RotatedRect& rect2, OutputArray intersectingRegion  );

CV_EXPORTS_W Ptr<CLAHE> createCLAHE(double clipLimit = 40.0, Size tileGridSize = Size(8, 8));

//! Ballard, D.H. (1981). Generalizing the Hough transform to detect arbitrary shapes. Pattern Recognition 13 (2): 111-122.
//! Detects position only without traslation and rotation
CV_EXPORTS Ptr<GeneralizedHoughBallard> createGeneralizedHoughBallard();

//! Guil, N., González-Linares, J.M. and Zapata, E.L. (1999). Bidimensional shape detection using an invariant approach. Pattern Recognition 32 (6): 1025-1038.
//! Detects position, traslation and rotation
CV_EXPORTS Ptr<GeneralizedHoughGuil> createGeneralizedHoughGuil();

//! Performs linear blending of two images
CV_EXPORTS void blendLinear(InputArray src1, InputArray src2, InputArray weights1, InputArray weights2, OutputArray dst);

} // cv

#endif
",16227,False,2303.554996112222,median
"/**********************************************************************
 * File:        oldbasel.cpp  (Formerly oldbl.c)
 * Description: A re-implementation of the old baseline algorithm.
 * Author:      Ray Smith
 *
 * (C) Copyright 1993, Hewlett-Packard Ltd.
 ** 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 automatically generated configuration file if running autoconf.
#ifdef HAVE_TESSERACT_CONFIG_H
#  include ""config_auto.h""
#endif

#include ""oldbasel.h""

#include ""ccstruct.h""
#include ""detlinefit.h""
#include ""drawtord.h""
#include ""makerow.h""
#include ""quadlsq.h""
#include ""statistc.h""
#include ""textord.h""
#include ""tprintf.h""

#include <cmath>
#include <vector> // for std::vector

#include <algorithm>

namespace tesseract {

static BOOL_VAR(textord_really_old_xheight, false, ""Use original wiseowl xheight"");
BOOL_VAR(textord_oldbl_debug, false, ""Debug old baseline generation"");
static BOOL_VAR(textord_debug_baselines, false, ""Debug baseline generation"");
static BOOL_VAR(textord_oldbl_paradef, true, ""Use para default mechanism"");
static BOOL_VAR(textord_oldbl_split_splines, true, ""Split stepped splines"");
static BOOL_VAR(textord_oldbl_merge_parts, true, ""Merge suspect partitions"");
static BOOL_VAR(oldbl_corrfix, true, ""Improve correlation of heights"");
static BOOL_VAR(oldbl_xhfix, false, ""Fix bug in modes threshold for xheights"");
static BOOL_VAR(textord_ocropus_mode, false, ""Make baselines for ocropus"");
static double_VAR(oldbl_xhfract, 0.4, ""Fraction of est allowed in calc"");
static INT_VAR(oldbl_holed_losscount, 10, ""Max lost before fallback line used"");
static double_VAR(oldbl_dot_error_size, 1.26, ""Max aspect ratio of a dot"");
static double_VAR(textord_oldbl_jumplimit, 0.15, ""X fraction for new partition"");

#define TURNLIMIT 1            /*min size for turning point */
#define X_HEIGHT_FRACTION 0.7  /*x-height/caps height */
#define DESCENDER_FRACTION 0.5 /*descender/x-height */
#define MIN_ASC_FRACTION 0.20  /*min size of ascenders */
#define MIN_DESC_FRACTION 0.25 /*min size of descenders */
#define MINASCRISE 2.0         /*min ascender/desc step */
#define MAXHEIGHTVARIANCE 0.15 /*accepted variation in x-height */
#define MAXHEIGHT 300          /*max blob height */
#define MAXOVERLAP 0.1         /*max 10% missed overlap */
#define MAXBADRUN 2            /*max non best for failed */
#define HEIGHTBUCKETS 200      /* Num of buckets */
#define MODENUM 10
#define MAXPARTS 6
#define SPLINESIZE 23

#define ABS(x) ((x) < 0 ? (-(x)) : (x))

/**********************************************************************
 * make_old_baselines
 *
 * Top level function to make baselines the old way.
 **********************************************************************/

void Textord::make_old_baselines(TO_BLOCK *block, // block to do
                                 bool testing_on, // correct orientation
                                 float gradient) {
  QSPLINE *prev_baseline; // baseline of previous row
  TO_ROW *row;            // current row
  TO_ROW_IT row_it = block->get_rows();
  BLOBNBOX_IT blob_it;

  prev_baseline = nullptr; // nothing yet
  for (row_it.mark_cycle_pt(); !row_it.cycled_list(); row_it.forward()) {
    row = row_it.data();
    find_textlines(block, row, 2, nullptr);
    if (row->xheight <= 0 && prev_baseline != nullptr) {
      find_textlines(block, row, 2, prev_baseline);
    }
    if (row->xheight > 0) { // was a good one
      prev_baseline = &row->baseline;
    } else {
      prev_baseline = nullptr;
      blob_it.set_to_list(row->blob_list());
      if (textord_debug_baselines) {
        tprintf(""Row baseline generation failed on row at (%d,%d)\\n"",
                blob_it.data()->bounding_box().left(), blob_it.data()->bounding_box().bottom());
      }
    }
  }
  correlate_lines(block, gradient);
  block->block->set_xheight(block->xheight);
}

/**********************************************************************
 * correlate_lines
 *
 * Correlate the x-heights and ascender heights of a block to fill-in
 * the ascender height and descender height for rows without one.
 * Also fix baselines of rows without a decent fit.
 **********************************************************************/

void Textord::correlate_lines(TO_BLOCK *block, float gradient) {
  int rowcount; /*no of rows to do */
  int rowindex; /*no of row */
                // iterator
  TO_ROW_IT row_it = block->get_rows();

  rowcount = row_it.length();
  if (rowcount == 0) {
    // default value
    block->xheight = block->line_size;
    return; /*none to do */
  }
  // array of ptrs
  std::vector<TO_ROW *> rows(rowcount);
  rowindex = 0;
  for (row_it.mark_cycle_pt(); !row_it.cycled_list(); row_it.forward()) {
    // make array
    rows[rowindex++] = row_it.data();
  }

  /*try to fix bad lines */
  correlate_neighbours(block, &rows[0], rowcount);

  if (textord_really_old_xheight || textord_old_xheight) {
    block->xheight = static_cast<float>(correlate_with_stats(&rows[0], rowcount, block));
    if (block->xheight <= 0) {
      block->xheight = block->line_size * tesseract::CCStruct::kXHeightFraction;
    }
    if (block->xheight < textord_min_xheight) {
      block->xheight = (float)textord_min_xheight;
    }
  } else {
    compute_block_xheight(block, gradient);
  }
}

/**********************************************************************
 * correlate_neighbours
 *
 * Try to fix rows that had a bad spline fit by using neighbours.
 **********************************************************************/

void Textord::correlate_neighbours(TO_BLOCK *block, // block rows are in.
                                   TO_ROW **rows,   // rows of block.
                                   int rowcount) {  // no of rows to do.
  TO_ROW *row;                                      /*current row */
  int rowindex;                                     /*no of row */
  int otherrow;                                     /*second row */
  int upperrow;                                     /*row above to use */
  int lowerrow;                                     /*row below to use */
  float biggest;

  for (rowindex = 0; rowindex < rowcount; rowindex++) {
    row = rows[rowindex]; /*current row */
    if (row->xheight < 0) {
      /*quadratic failed */
      for (otherrow = rowindex - 2;
           otherrow >= 0 && (rows[otherrow]->xheight < 0.0 ||
                             !row->baseline.overlap(&rows[otherrow]->baseline, MAXOVERLAP));
           otherrow--) {
        ;
      }
      upperrow = otherrow; /*decent row above */
      for (otherrow = rowindex + 1;
           otherrow < rowcount && (rows[otherrow]->xheight < 0.0 ||
                                   !row->baseline.overlap(&rows[otherrow]->baseline, MAXOVERLAP));
           otherrow++) {
        ;
      }
      lowerrow = otherrow; /*decent row below */
      if (upperrow >= 0) {
        find_textlines(block, row, 2, &rows[upperrow]->baseline);
      }
      if (row->xheight < 0 && lowerrow < rowcount) {
        find_textlines(block, row, 2, &rows[lowerrow]->baseline);
      }
      if (row->xheight < 0) {
        if (upperrow >= 0) {
          find_textlines(block, row, 1, &rows[upperrow]->baseline);
        } else if (lowerrow < rowcount) {
          find_textlines(block, row, 1, &rows[lowerrow]->baseline);
        }
      }
    }
  }

  for (biggest = 0.0f, rowindex = 0; rowindex < rowcount; rowindex++) {
    row = rows[rowindex]; /*current row */
    if (row->xheight < 0) { /*linear failed */
                            /*make do */
      row->xheight = -row->xheight;
    }
    biggest = std::max(biggest, row->xheight);
  }
}

/**********************************************************************
 * correlate_with_stats
 *
 * correlate the x-heights and ascender heights of a block to fill-in
 * the ascender height and descender height for rows without one.
 **********************************************************************/

int Textord::correlate_with_stats(TO_ROW **rows, // rows of block.
                                  int rowcount,  // no of rows to do.
                                  TO_BLOCK *block) {
  TO_ROW *row;         /*current row */
  int rowindex;        /*no of row */
  float lineheight;    /*mean x-height */
  float ascheight;     /*average ascenders */
  float minascheight;  /*min allowed ascheight */
  int xcount;          /*no of samples for xheight */
  float fullheight;    /*mean top height */
  int fullcount;       /*no of samples */
  float descheight;    /*mean descender drop */
  float mindescheight; /*min allowed descheight */
  int desccount;       /*no of samples */

  /*no samples */
  xcount = fullcount = desccount = 0;
  lineheight = ascheight = fullheight = descheight = 0.0;
  for (rowindex = 0; rowindex < rowcount; rowindex++) {
    row = rows[rowindex];         /*current row */
    if (row->ascrise > 0.0) {     /*got ascenders? */
      lineheight += row->xheight; /*average x-heights */
      ascheight += row->ascrise;  /*average ascenders */
      xcount++;
    } else {
      fullheight += row->xheight; /*assume full height */
      fullcount++;
    }
    if (row->descdrop < 0.0) { /*got descenders? */
                               /*average descenders */
      descheight += row->descdrop;
      desccount++;
    }
  }

  if (xcount > 0 && (!oldbl_corrfix || xcount >= fullcount)) {
    lineheight /= xcount; /*average x-height */
                          /*average caps height */
    fullheight = lineheight + ascheight / xcount;
    /*must be decent size */
    if (fullheight < lineheight * (1 + MIN_ASC_FRACTION)) {
      fullheight = lineheight * (1 + MIN_ASC_FRACTION);
    }
  } else {
    fullheight /= fullcount; /*average max height */
                             /*guess x-height */
    lineheight = fullheight * X_HEIGHT_FRACTION;
  }
  if (desccount > 0 && (!oldbl_corrfix || desccount >= rowcount / 2)) {
    descheight /= desccount; /*average descenders */
  } else {
    /*guess descenders */
    descheight = -lineheight * DESCENDER_FRACTION;
  }

  if (lineheight > 0.0f) {
    block->block->set_cell_over_xheight((fullheight - descheight) / lineheight);
  }

  minascheight = lineheight * MIN_ASC_FRACTION;
  mindescheight = -lineheight * MIN_DESC_FRACTION;
  for (rowindex = 0; rowindex < rowcount; rowindex++) {
    row = rows[rowindex]; /*do each row */
    row->all_caps = false;
    if (row->ascrise / row->xheight < MIN_ASC_FRACTION) {
      /*no ascenders */
      if (row->xheight >= lineheight * (1 - MAXHEIGHTVARIANCE) &&
          row->xheight <= lineheight * (1 + MAXHEIGHTVARIANCE)) {
        row->ascrise = fullheight - lineheight;
        /*set to average */
        row->xheight = lineheight;

      } else if (row->xheight >= fullheight * (1 - MAXHEIGHTVARIANCE) &&
                 row->xheight <= fullheight * (1 + MAXHEIGHTVARIANCE)) {
        row->ascrise = row->xheight - lineheight;
        /*set to average */
        row->xheight = lineheight;
        row->all_caps = true;
      } else {
        row->ascrise = (fullheight - lineheight) * row->xheight / fullheight;
        /*scale it */
        row->xheight -= row->ascrise;
        row->all_caps = true;
      }
      if (row->ascrise < minascheight) {
        row->ascrise = row->xheight * ((1.0 - X_HEIGHT_FRACTION) / X_HEIGHT_FRACTION);
      }
    }
    if (row->descdrop > mindescheight) {
      if (row->xheight >= lineheight * (1 - MAXHEIGHTVARIANCE) &&
          row->xheight <= lineheight * (1 + MAXHEIGHTVARIANCE)) {
        /*set to average */
        row->descdrop = descheight;
      } else {
        row->descdrop = -row->xheight * DESCENDER_FRACTION;
      }
    }
  }
  return static_cast<int>(lineheight); // block xheight
}

/**********************************************************************
 * find_textlines
 *
 * Compute the baseline for the given row.
 **********************************************************************/

void Textord::find_textlines(TO_BLOCK *block,   // block row is in
                             TO_ROW *row,       // row to do
                             int degree,        // required approximation
                             QSPLINE *spline) { // starting spline
  int partcount;                                /*no of partitions of */
  bool holed_line = false;                      // lost too many blobs
  int bestpart;                                 /*biggest partition */
  int partsizes[MAXPARTS];                      /*no in each partition */
  int lineheight;                               /*guessed x-height */
  float jumplimit;                              /*allowed delta change */
  int blobcount;                                /*no of blobs on line */
  int pointcount;                               /*no of coords */
  int xstarts[SPLINESIZE + 1];                  // segment boundaries
  int segments;                                 // no of segments

  // no of blobs in row
  blobcount = row->blob_list()->length();
  // partition no of each blob
  std::vector<char> partids(blobcount);
  // useful sample points
  std::vector<int> xcoords(blobcount);
  // useful sample points
  std::vector<int> ycoords(blobcount);
  // edges of blob rectangles
  std::vector<TBOX> blobcoords(blobcount);
  // diffs from 1st approx
  std::vector<float> ydiffs(blobcount);

  lineheight = get_blob_coords(row, static_cast<int>(block->line_size), &blobcoords[0], holed_line,
                               blobcount);
  /*limit for line change */
  jumplimit = lineheight * textord_oldbl_jumplimit;
  if (jumplimit < MINASCRISE) {
    jumplimit = MINASCRISE;
  }

  if (textord_oldbl_debug) {
    tprintf(""\\nInput height=%g, Estimate x-height=%d pixels, jumplimit=%.2f\\n"", block->line_size,
            lineheight, jumplimit);
  }
  if (holed_line) {
    make_holed_baseline(&blobcoords[0], blobcount, spline, &row->baseline, row->line_m());
  } else {
    make_first_baseline(&blobcoords[0], blobcount, &xcoords[0], &ycoords[0], spline, &row->baseline,
                        jumplimit);
  }
#ifndef GRAPHICS_DISABLED
  if (textord_show_final_rows) {
    row->baseline.plot(to_win, ScrollView::GOLDENROD);
  }
#endif
  if (blobcount > 1) {
    bestpart = partition_line(&blobcoords[0], blobcount, &partcount, &partids[0], partsizes,
                              &row->baseline, jumplimit, &ydiffs[0]);
    pointcount = partition_coords(&blobcoords[0], blobcount, &partids[0], bestpart, &xcoords[0],
                                  &ycoords[0]);
    segments = segment_spline(&blobcoords[0], blobcount, &xcoords[0], &ycoords[0], degree,
                              pointcount, xstarts);
    if (!holed_line) {
      do {
        row->baseline = QSPLINE(xstarts, segments, &xcoords[0], &ycoords[0], pointcount, degree);
      } while (textord_oldbl_split_splines &&
               split_stepped_spline(&row->baseline, jumplimit / 2, &xcoords[0], xstarts, segments));
    }
    find_lesser_parts(row, &blobcoords[0], blobcount, &partids[0], partsizes, partcount, bestpart);

  } else {
    row->xheight = -1.0f; /*failed */
    row->descdrop = 0.0f;
    row->ascrise = 0.0f;
  }
  row->baseline.extrapolate(row->line_m(), block->block->pdblk.bounding_box().left(),
                            block->block->pdblk.bounding_box().right());

  if (textord_really_old_xheight) {
    old_first_xheight(row, &blobcoords[0], lineheight, blobcount, &row->baseline, jumplimit);
  } else if (textord_old_xheight) {
    make_first_xheight(row, &blobcoords[0], lineheight, static_cast<int>(block->line_size),
                       blobcount, &row->baseline, jumplimit);
  } else {
    compute_row_xheight(row, block->block->classify_rotation(), row->line_m(), block->line_size);
  }
}

/**********************************************************************
 * get_blob_coords
 *
 * Fill the blobcoords array with the coordinates of the blobs
 * in the row. The return value is the first guess at the line height.
 **********************************************************************/

int get_blob_coords(    // get boxes
    TO_ROW *row,        // row to use
    int32_t lineheight, // block level
    TBOX *blobcoords,   // output boxes
    bool &holed_line,   // lost a lot of blobs
    int &outcount       // no of real blobs
) {
  // blobs
  BLOBNBOX_IT blob_it = row->blob_list();
  int blobindex;    /*no along text line */
  int losscount;    // lost blobs
  int maxlosscount; // greatest lost blobs
  /*height stat collection */
  STATS heightstat(0, MAXHEIGHT);

  if (blob_it.empty()) {
    return 0; // none
  }
  maxlosscount = 0;
  losscount = 0;
  blob_it.mark_cycle_pt();
  blobindex = 0;
  do {
    blobcoords[blobindex] = box_next_pre_chopped(&blob_it);
    if (blobcoords[blobindex].height() > lineheight * 0.25) {
      heightstat.add(blobcoords[blobindex].height(), 1);
    }
    if (blobindex == 0 || blobcoords[blobindex].height() > lineheight * 0.25 ||
        blob_it.cycled_list()) {
      blobindex++; /*no of merged blobs */
      losscount = 0;
    } else {
      if (blobcoords[blobindex].height() < blobcoords[blobindex].width() * oldbl_dot_error_size &&
          blobcoords[blobindex].width() < blobcoords[blobindex].height() * oldbl_dot_error_size) {
        // counts as dot
        blobindex++;
        losscount = 0;
      } else {
        losscount++; // lost it
        if (losscount > maxlosscount) {
          // remember max
          maxlosscount = losscount;
        }
      }
    }
  } while (!blob_it.cycled_list());

  holed_line = maxlosscount > oldbl_holed_losscount;
  outcount = blobindex; /*total blobs */

  if (heightstat.get_total() > 1) {
    /*guess x-height */
    return static_cast<int>(heightstat.ile(0.25));
  } else {
    return blobcoords[0].height();
  }
}

/**********************************************************************
 * make_first_baseline
 *
 * Make the first estimate at a baseline, either by shifting
 * a supplied previous spline, or by doing a piecewise linear
 * approximation using all the blobs.
 **********************************************************************/

void make_first_baseline( // initial approximation
    TBOX blobcoords[],    /*blob bounding boxes */
    int blobcount,        /*no of blobcoords */
    int xcoords[],        /*coords for spline */
    int ycoords[],        /*approximator */
    QSPLINE *spline,      /*initial spline */
    QSPLINE *baseline,    /*output spline */
    float jumplimit       /*guess half descenders */
) {
  int leftedge;              /*left edge of line */
  int rightedge;             /*right edge of line */
  int blobindex;             /*current blob */
  int segment;               /*current segment */
  float prevy, thisy, nexty; /*3 y coords */
  float y1, y2, y3;          /*3 smooth blobs */
  float maxmax, minmin;      /*absolute limits */
  int x2 = 0;                /*right edge of old y3 */
  int ycount;                /*no of ycoords in use */
  float yturns[SPLINESIZE];  /*y coords of turn pts */
  int xturns[SPLINESIZE];    /*xcoords of turn pts */
  int xstarts[SPLINESIZE + 1];
  int segments; // no of segments
  ICOORD shift; // shift of spline

  prevy = 0;
  /*left edge of row */
  leftedge = blobcoords[0].left();
  /*right edge of line */
  rightedge = blobcoords[blobcount - 1].right();
  if (spline == nullptr       /*no given spline */
      || spline->segments < 3 /*or trivial */
                              /*or too non-overlap */
      || spline->xcoords[1] > leftedge + MAXOVERLAP * (rightedge - leftedge) ||
      spline->xcoords[spline->segments - 1] < rightedge - MAXOVERLAP * (rightedge - leftedge)) {
    if (textord_oldbl_paradef) {
      return; // use default
    }
    xstarts[0] = blobcoords[0].left() - 1;
    for (blobindex = 0; blobindex < blobcount; blobindex++) {
      xcoords[blobindex] = (blobcoords[blobindex].left() + blobcoords[blobindex].right()) / 2;
      ycoords[blobindex] = blobcoords[blobindex].bottom();
    }
    xstarts[1] = blobcoords[blobcount - 1].right() + 1;
    segments = 1; /*no of segments */

    /*linear */
    *baseline = QSPLINE(xstarts, segments, xcoords, ycoords, blobcount, 1);

    if (blobcount >= 3) {
      y1 = y2 = y3 = 0.0f;
      ycount = 0;
      segment = 0; /*no of segments */
      maxmax = minmin = 0.0f;
      thisy = ycoords[0] - baseline->y(xcoords[0]);
      nexty = ycoords[1] - baseline->y(xcoords[1]);
      for (blobindex = 2; blobindex < blobcount; blobindex++) {
        prevy = thisy; /*shift ycoords */
        thisy = nexty;
        nexty = ycoords[blobindex] - baseline->y(xcoords[blobindex]);
        /*middle of smooth y */
        if (ABS(thisy - prevy) < jumplimit && ABS(thisy - nexty) < jumplimit) {
          y1 = y2; /*shift window */
          y2 = y3;
          y3 = thisy; /*middle point */
          ycount++;
          /*local max */
          if (ycount >= 3 && ((y1 < y2 && y2 >= y3)
                              /*local min */
                              || (y1 > y2 && y2 <= y3))) {
            if (segment < SPLINESIZE - 2) {
              /*turning pt */
              xturns[segment] = x2;
              yturns[segment] = y2;
              segment++; /*no of spline segs */
            }
          }
          if (ycount == 1) {
            maxmax = minmin = y3; /*initialise limits */
          } else {
            if (y3 > maxmax) {
              maxmax = y3; /*biggest max */
            }
            if (y3 < minmin) {
              minmin = y3; /*smallest min */
            }
          }
          /*possible turning pt */
          x2 = blobcoords[blobindex - 1].right();
        }
      }

      jumplimit *= 1.2f;
      /*must be wavy */
      if (maxmax - minmin > jumplimit) {
        ycount = segment; /*no of segments */
        for (blobindex = 0, segment = 1; blobindex < ycount; blobindex++) {
          if (yturns[blobindex] > minmin + jumplimit || yturns[blobindex] < maxmax - jumplimit) {
            /*significant peak */
            if (segment == 1 || yturns[blobindex] > prevy + jumplimit ||
                yturns[blobindex] < prevy - jumplimit) {
              /*different to previous */
              xstarts[segment] = xturns[blobindex];
              segment++;
              prevy = yturns[blobindex];
            }
            /*bigger max */
            else if ((prevy > minmin + jumplimit && yturns[blobindex] > prevy)
                     /*smaller min */
                     || (prevy < maxmax - jumplimit && yturns[blobindex] < prevy)) {
              xstarts[segment - 1] = xturns[blobindex];
              /*improved previous */
              prevy = yturns[blobindex];
            }
          }
        }
        xstarts[segment] = blobcoords[blobcount - 1].right() + 1;
        segments = segment; /*no of segments */
                            /*linear */
        *baseline = QSPLINE(xstarts, segments, xcoords, ycoords, blobcount, 1);
      }
    }
  } else {
    *baseline = *spline; /*copy it */
    shift =
        ICOORD(0, static_cast<int16_t>(blobcoords[0].bottom() - spline->y(blobcoords[0].right())));
    baseline->move(shift);
  }
}

/**********************************************************************
 * make_holed_baseline
 *
 * Make the first estimate at a baseline, either by shifting
 * a supplied previous spline, or by doing a piecewise linear
 * approximation using all the blobs.
 **********************************************************************/

void make_holed_baseline( // initial approximation
    TBOX blobcoords[],    /*blob bounding boxes */
    int blobcount,        /*no of blobcoords */
    QSPLINE *spline,      /*initial spline */
    QSPLINE *baseline,    /*output spline */
    float gradient        // of line
) {
  int leftedge;  /*left edge of line */
  int rightedge; /*right edge of line */
  int blobindex; /*current blob */
  float x;       // centre of row
  ICOORD shift;  // shift of spline

  tesseract::DetLineFit lms; // straight baseline
  int32_t xstarts[2];        // straight line
  double coeffs[3];
  float c; // line parameter

  /*left edge of row */
  leftedge = blobcoords[0].left();
  /*right edge of line */
  rightedge = blobcoords[blobcount - 1].right();
  for (blobindex = 0; blobindex < blobcount; blobindex++) {
    lms.Add(ICOORD((blobcoords[blobindex].left() + blobcoords[blobindex].right()) / 2,
                   blobcoords[blobindex].bottom()));
  }
  lms.ConstrainedFit(gradient, &c);
  xstarts[0] = leftedge;
  xstarts[1] = rightedge;
  coeffs[0] = 0;
  coeffs[1] = gradient;
  coeffs[2] = c;
  *baseline = QSPLINE(1, xstarts, coeffs);
  if (spline != nullptr        /*no given spline */
      && spline->segments >= 3 /*or trivial */
                               /*or too non-overlap */
      && spline->xcoords[1] <= leftedge + MAXOVERLAP * (rightedge - leftedge) &&
      spline->xcoords[spline->segments - 1] >= rightedge - MAXOVERLAP * (rightedge - leftedge)) {
    *baseline = *spline; /*copy it */
    x = (leftedge + rightedge) / 2.0;
    shift = ICOORD(0, static_cast<int16_t>(gradient * x + c - spline->y(x)));
    baseline->move(shift);
  }
}

/**********************************************************************
 * partition_line
 *
 * Partition a row of blobs into different groups of continuous
 * y position. jumplimit specifies the max allowable limit on a jump
 * before a new partition is started.
 * The return value is the biggest partition
 **********************************************************************/

int partition_line(    // partition blobs
    TBOX blobcoords[], // bounding boxes
    int blobcount,     /*no of blobs on row */
    int *numparts,     /*number of partitions */
    char partids[],    /*partition no of each blob */
    int partsizes[],   /*no in each partition */
    QSPLINE *spline,   /*curve to fit to */
    float jumplimit,   /*allowed delta change */
    float ydiffs[]     /*diff from spline */
) {
  int blobindex;             /*no along text line */
  int bestpart;              /*best new partition */
  int biggestpart;           /*part with most members */
  float diff;                /*difference from line */
  int startx;                /*index of start blob */
  float partdiffs[MAXPARTS]; /*step between parts */

  for (bestpart = 0; bestpart < MAXPARTS; bestpart++) {
    partsizes[bestpart] = 0; /*zero them all */
  }

  startx = get_ydiffs(blobcoords, blobcount, spline, ydiffs);
  *numparts = 1; /*1 partition */
  bestpart = -1; /*first point */
  float drift = 0.0f;
  float last_delta = 0.0f;
  for (blobindex = startx; blobindex < blobcount; blobindex++) {
    /*do each blob in row */
    diff = ydiffs[blobindex]; /*diff from line */
    if (textord_oldbl_debug) {
      tprintf(""%d(%d,%d), "", blobindex, blobcoords[blobindex].left(),
              blobcoords[blobindex].bottom());
    }
    bestpart =
        choose_partition(diff, partdiffs, bestpart, jumplimit, &drift, &last_delta, numparts);
    /*record partition */
    partids[blobindex] = bestpart;
    partsizes[bestpart]++; /*another in it */
  }

  bestpart = -1; /*first point */
  drift = 0.0f;
  last_delta = 0.0f;
  partsizes[0]--; /*doing 1st pt again */
                  /*do each blob in row */
  for (blobindex = startx; blobindex >= 0; blobindex--) {
    diff = ydiffs[blobindex]; /*diff from line */
    if (textord_oldbl_debug) {
      tprintf(""%d(%d,%d), "", blobindex, blobcoords[blobindex].left(),
              blobcoords[blobindex].bottom());
    }
    bestpart =
        choose_partition(diff, partdiffs, bestpart, jumplimit, &drift, &last_delta, numparts);
    /*record partition */
    partids[blobindex] = bestpart;
    partsizes[bestpart]++; /*another in it */
  }

  for (biggestpart = 0, bestpart = 1; bestpart < *numparts; bestpart++) {
    if (partsizes[bestpart] >= partsizes[biggestpart]) {
      biggestpart = bestpart; /*new biggest */
    }
  }
  if (textord_oldbl_merge_parts) {
    merge_oldbl_parts(blobcoords, blobcount, partids, partsizes, biggestpart, jumplimit);
  }
  return biggestpart; /*biggest partition */
}

/**********************************************************************
 * merge_oldbl_parts
 *
 * For any adjacent group of blobs in a different part, put them in the
 * main part if they fit closely to neighbours in the main part.
 **********************************************************************/

void merge_oldbl_parts( // partition blobs
    TBOX blobcoords[],  // bounding boxes
    int blobcount,      /*no of blobs on row */
    char partids[],     /*partition no of each blob */
    int partsizes[],    /*no in each partition */
    int biggestpart,    // major partition
    float jumplimit     /*allowed delta change */
) {
  bool found_one; // found a bestpart blob
  bool close_one; // found was close enough
  int blobindex;  /*no along text line */
  int prevpart;   // previous iteration
  int runlength;  // no in this part
  float diff;     /*difference from line */
  int startx;     /*index of start blob */
  int test_blob;  // another index
  FCOORD coord;   // blob coordinate
  float m, c;     // fitted line
  QLSQ stats;     // line stuff

  prevpart = biggestpart;
  runlength = 0;
  startx = 0;
  for (blobindex = 0; blobindex < blobcount; blobindex++) {
    if (partids[blobindex] != prevpart) {
      //                      tprintf(""Partition change at (%d,%d) from %d to %d
      //                      after run of %d\\n"",
      //                              blobcoords[blobindex].left(),blobcoords[blobindex].bottom(),
      //                              prevpart,partids[blobindex],runlength);
      if (prevpart != biggestpart && runlength > MAXBADRUN) {
        stats.clear();
        for (test_blob = startx; test_blob < blobindex; test_blob++) {
          coord = FCOORD((blobcoords[test_blob].left() + blobcoords[test_blob].right()) / 2.0,
                         blobcoords[test_blob].bottom());
          stats.add(coord.x(), coord.y());
        }
        stats.fit(1);
        m = stats.get_b();
        c = stats.get_c();
        if (textord_oldbl_debug) {
          tprintf(""Fitted line y=%g x + %g\\n"", m, c);
        }
        found_one = false;
        close_one = false;
        for (test_blob = 1;
             !found_one && (startx - test_blob >= 0 || blobindex + test_blob <= blobcount);
             test_blob++) {
          if (startx - test_blob >= 0 && partids[startx - test_blob] == biggestpart) {
            found_one = true;
            coord = FCOORD(
                (blobcoords[startx - test_blob].left() + blobcoords[startx - test_blob].right()) /
                    2.0,
                blobcoords[startx - test_blob].bottom());
            diff = m * coord.x() + c - coord.y();
            if (textord_oldbl_debug) {
              tprintf(""Diff of common blob to suspect part=%g at (%g,%g)\\n"", diff, coord.x(),
                      coord.y());
            }
            if (diff < jumplimit && -diff < jumplimit) {
              close_one = true;
            }
          }
          if (blobindex + test_blob <= blobcount &&
              partids[blobindex + test_blob - 1] == biggestpart) {
            found_one = true;
            coord = FCOORD((blobcoords[blobindex + test_blob - 1].left() +
                            blobcoords[blobindex + test_blob - 1].right()) /
                               2.0,
                           blobcoords[blobindex + test_blob - 1].bottom());
            diff = m * coord.x() + c - coord.y();
            if (textord_oldbl_debug) {
              tprintf(""Diff of common blob to suspect part=%g at (%g,%g)\\n"", diff, coord.x(),
                      coord.y());
            }
            if (diff < jumplimit && -diff < jumplimit) {
              close_one = true;
            }
          }
        }
        if (close_one) {
          if (textord_oldbl_debug) {
            tprintf(
                ""Merged %d blobs back into part %d from %d starting at ""
                ""(%d,%d)\\n"",
                runlength, biggestpart, prevpart, blobcoords[startx].left(),
                blobcoords[startx].bottom());
          }
          // switch sides
          partsizes[prevpart] -= runlength;
          for (test_blob = startx; test_blob < blobindex; test_blob++) {
            partids[test_blob] = biggestpart;
          }
        }
      }
      prevpart = partids[blobindex];
      runlength = 1;
      startx = blobindex;
    } else {
      runlength++;
    }
  }
}

/**********************************************************************
 * get_ydiffs
 *
 * Get the differences between the blobs and the spline,
 * putting them in ydiffs.  The return value is the index
 * of the blob in the middle of the ""best behaved"" region
 **********************************************************************/

int get_ydiffs(        // evaluate differences
    TBOX blobcoords[], // bounding boxes
    int blobcount,     /*no of blobs */
    QSPLINE *spline,   /*approximating spline */
    float ydiffs[]     /*output */
) {
  int blobindex; /*current blob */
  int xcentre;   /*xcoord */
  int lastx;     /*last xcentre */
  float diffsum; /*sum of diffs */
  float diff;    /*current difference */
  float drift;   /*sum of spline steps */
  float bestsum; /*smallest diffsum */
  int bestindex; /*index of bestsum */

  diffsum = 0.0f;
  bestindex = 0;
  bestsum = static_cast<float>(INT32_MAX);
  drift = 0.0f;
  lastx = blobcoords[0].left();
  /*do each blob in row */
  for (blobindex = 0; blobindex < blobcount; blobindex++) {
    /*centre of blob */
    xcentre = (blobcoords[blobindex].left() + blobcoords[blobindex].right()) >> 1;
    // step functions in spline
    drift += spline->step(lastx, xcentre);
    lastx = xcentre;
    diff = blobcoords[blobindex].bottom();
    diff -= spline->y(xcentre);
    diff += drift;
    ydiffs[blobindex] = diff; /*store difference */
    if (blobindex > 2) {
      /*remove old one */
      diffsum -= ABS(ydiffs[blobindex - 3]);
    }
    diffsum += ABS(diff); /*add new one */
    if (blobindex >= 2 && diffsum < bestsum) {
      bestsum = diffsum;         /*find min sum */
      bestindex = blobindex - 1; /*middle of set */
    }
  }
  return bestindex;
}

/**********************************************************************
 * choose_partition
 *
 * Choose a partition for the point and return the index.
 **********************************************************************/

int choose_partition(                              // select partition
    float diff,                                    /*diff from spline */
    float partdiffs[],                             /*diff on all parts */
    int lastpart,                                  /*last assigned partition */
    float jumplimit,                               /*new part threshold */
    float *drift, float *lastdelta, int *partcount /*no of partitions */
) {
  int partition;   /*partition no */
  int bestpart;    /*best new partition */
  float bestdelta; /*best gap from a part */
  float delta;     /*diff from part */

  if (lastpart < 0) {
    partdiffs[0] = diff;
    lastpart = 0; /*first point */
    *drift = 0.0f;
    *lastdelta = 0.0f;
  }
  /*adjusted diff from part */
  delta = diff - partdiffs[lastpart] - *drift;
  if (textord_oldbl_debug) {
    tprintf(""Diff=%.2f, Delta=%.3f, Drift=%.3f, "", diff, delta, *drift);
  }
  if (ABS(delta) > jumplimit / 2) {
    /*delta on part 0 */
    bestdelta = diff - partdiffs[0] - *drift;
    bestpart = 0; /*0 best so far */
    for (partition = 1; partition < *partcount; partition++) {
      delta = diff - partdiffs[partition] - *drift;
      if (ABS(delta) < ABS(bestdelta)) {
        bestdelta = delta;
        bestpart = partition; /*part with nearest jump */
      }
    }
    delta = bestdelta;
    /*too far away */
    if (ABS(bestdelta) > jumplimit && *partcount < MAXPARTS) { /*and spare part left */
      bestpart = (*partcount)++;                               /*best was new one */
                                                               /*start new one */
      partdiffs[bestpart] = diff - *drift;
      delta = 0.0f;
    }
  } else {
    bestpart = lastpart; /*best was last one */
  }

  if (bestpart == lastpart &&
      (ABS(delta - *lastdelta) < jumplimit / 2 || ABS(delta) < jumplimit / 2)) {
    /*smooth the drift */
    *drift = (3 * *drift + delta) / 3;
  }
  *lastdelta = delta;

  if (textord_oldbl_debug) {
    tprintf(""P=%d\\n"", bestpart);
  }

  return bestpart;
}

/**********************************************************************
 * partition_coords
 *
 * Get the x,y coordinates of all points in the bestpart and put them
 * in xcoords,ycoords. Return the number of points found.
 **********************************************************************/

int partition_coords(  // find relevant coords
    TBOX blobcoords[], // bounding boxes
    int blobcount,     /*no of blobs in row */
    char partids[],    /*partition no of each blob */
    int bestpart,      /*best new partition */
    int xcoords[],     /*points to work on */
    int ycoords[]      /*points to work on */
) {
  int blobindex;  /*no along text line */
  int pointcount; /*no of points */

  pointcount = 0;
  for (blobindex = 0; blobindex < blobcount; blobindex++) {
    if (partids[blobindex] == bestpart) {
      /*centre of blob */
      xcoords[pointcount] = (blobcoords[blobindex].left() + blobcoords[blobindex].right()) >> 1;
      ycoords[pointcount++] = blobcoords[blobindex].bottom();
    }
  }
  return pointcount; /*no of points found */
}

/**********************************************************************
 * segment_spline
 *
 * Segment the row at midpoints between maxima and minima of the x,y pairs.
 * The xstarts of the segments are returned and the number found.
 **********************************************************************/

int segment_spline(             // make xstarts
    TBOX blobcoords[],          // boundign boxes
    int blobcount,              /*no of blobs in row */
    int xcoords[],              /*points to work on */
    int ycoords[],              /*points to work on */
    int degree, int pointcount, /*no of points */
    int xstarts[]               // result
) {
  int ptindex;                /*no along text line */
  int segment;                /*partition no */
  int lastmin, lastmax;       /*possible turn points */
  int turnpoints[SPLINESIZE]; /*good turning points */
  int turncount;              /*no of turning points */
  int max_x;                  // max specified coord

  xstarts[0] = xcoords[0] - 1; // leftmost defined pt
  max_x = xcoords[pointcount - 1] + 1;
  if (degree < 2) {
    pointcount = 0;
  }
  turncount = 0; /*no turning points yet */
  if (pointcount > 3) {
    ptindex = 1;
    lastmax = lastmin = 0; /*start with first one */
    while (ptindex < pointcount - 1 && turncount < SPLINESIZE - 1) {
      /*minimum */
      if (ycoords[ptindex - 1] > ycoords[ptindex] && ycoords[ptindex] <= ycoords[ptindex + 1]) {
        if (ycoords[ptindex] < ycoords[lastmax] - TURNLIMIT) {
          if (turncount == 0 || turnpoints[turncount - 1] != lastmax) {
            /*new max point */
            turnpoints[turncount++] = lastmax;
          }
          lastmin = ptindex; /*latest minimum */
        } else if (ycoords[ptindex] < ycoords[lastmin]) {
          lastmin = ptindex; /*lower minimum */
        }
      }

      /*maximum */
      if (ycoords[ptindex - 1] < ycoords[ptindex] && ycoords[ptindex] >= ycoords[ptindex + 1]) {
        if (ycoords[ptindex] > ycoords[lastmin] + TURNLIMIT) {
          if (turncount == 0 || turnpoints[turncount - 1] != lastmin) {
            /*new min point */
            turnpoints[turncount++] = lastmin;
          }
          lastmax = ptindex; /*latest maximum */
        } else if (ycoords[ptindex] > ycoords[lastmax]) {
          lastmax = ptindex; /*higher maximum */
        }
      }
      ptindex++;
    }
    /*possible global min */
    if (ycoords[ptindex] < ycoords[lastmax] - TURNLIMIT &&
        (turncount == 0 || turnpoints[turncount - 1] != lastmax)) {
      if (turncount < SPLINESIZE - 1) {
        /*2 more turns */
        turnpoints[turncount++] = lastmax;
      }
      if (turncount < SPLINESIZE - 1) {
        turnpoints[turncount++] = ptindex;
      }
    } else if (ycoords[ptindex] > ycoords[lastmin] + TURNLIMIT
               /*possible global max */
               && (turncount == 0 || turnpoints[turncount - 1] != lastmin)) {
      if (turncount < SPLINESIZE - 1) {
        /*2 more turns */
        turnpoints[turncount++] = lastmin;
      }
      if (turncount < SPLINESIZE - 1) {
        turnpoints[turncount++] = ptindex;
      }
    } else if (turncount > 0 && turnpoints[turncount - 1] == lastmin &&
               turncount < SPLINESIZE - 1) {
      if (ycoords[ptindex] > ycoords[lastmax]) {
        turnpoints[turncount++] = ptindex;
      } else {
        turnpoints[turncount++] = lastmax;
      }
    } else if (turncount > 0 && turnpoints[turncount - 1] == lastmax &&
               turncount < SPLINESIZE - 1) {
      if (ycoords[ptindex] < ycoords[lastmin]) {
        turnpoints[turncount++] = ptindex;
      } else {
        turnpoints[turncount++] = lastmin;
      }
    }
  }

  if (textord_oldbl_debug && turncount > 0) {
    tprintf(""First turn is %d at (%d,%d)\\n"", turnpoints[0], xcoords[turnpoints[0]],
            ycoords[turnpoints[0]]);
  }
  for (segment = 1; segment < turncount; segment++) {
    /*centre y coord */
    lastmax = (ycoords[turnpoints[segment - 1]] + ycoords[turnpoints[segment]]) / 2;

    /* fix alg so that it works with both rising and falling sections */
    if (ycoords[turnpoints[segment - 1]] < ycoords[turnpoints[segment]]) {
      /*find rising y centre */
      for (ptindex = turnpoints[segment - 1] + 1;
           ptindex < turnpoints[segment] && ycoords[ptindex + 1] <= lastmax; ptindex++) {
        ;
      }
    } else {
      /*find falling y centre */
      for (ptindex = turnpoints[segment - 1] + 1;
           ptindex < turnpoints[segment] && ycoords[ptindex + 1] >= lastmax; ptindex++) {
        ;
      }
    }

    /*centre x */
    xstarts[segment] = (xcoords[ptindex - 1] + xcoords[ptindex] + xcoords[turnpoints[segment - 1]] +
                        xcoords[turnpoints[segment]] + 2) /
                       4;
    /*halfway between turns */
    if (textord_oldbl_debug) {
      tprintf(""Turn %d is %d at (%d,%d), mid pt is %d@%d, final @%d\\n"", segment,
              turnpoints[segment], xcoords[turnpoints[segment]], ycoords[turnpoints[segment]],
              ptindex - 1, xcoords[ptindex - 1], xstarts[segment]);
    }
  }

  xstarts[segment] = max_x;
  return segment; /*no of splines */
}

/**********************************************************************
 * split_stepped_spline
 *
 * Re-segment the spline in cases where there is a big step function.
 * Return true if any were done.
 **********************************************************************/

bool split_stepped_spline( // make xstarts
    QSPLINE *baseline,     // current shot
    float jumplimit,       // max step function
    int *xcoords,          /*points to work on */
    int *xstarts,          // result
    int &segments          // no of segments
) {
  bool doneany; // return value
  int segment;  /*partition no */
  int startindex, centreindex, endindex;
  float leftcoord, rightcoord;
  int leftindex, rightindex;
  float step; // spline step

  doneany = false;
  startindex = 0;
  for (segment = 1; segment < segments - 1; segment++) {
    step = baseline->step((xstarts[segment - 1] + xstarts[segment]) / 2.0,
                          (xstarts[segment] + xstarts[segment + 1]) / 2.0);
    if (step < 0) {
      step = -step;
    }
    if (step > jumplimit) {
      while (xcoords[startindex] < xstarts[segment - 1]) {
        startindex++;
      }
      centreindex = startindex;
      while (xcoords[centreindex] < xstarts[segment]) {
        centreindex++;
      }
      endindex = centreindex;
      while (xcoords[endindex] < xstarts[segment + 1]) {
        endindex++;
      }
      if (segments >= SPLINESIZE) {
        if (textord_debug_baselines) {
          tprintf(""Too many segments to resegment spline!!\\n"");
        }
      } else if (endindex - startindex >= textord_spline_medianwin * 3) {
        while (centreindex - startindex < textord_spline_medianwin * 3 / 2) {
          centreindex++;
        }
        while (endindex - centreindex < textord_spline_medianwin * 3 / 2) {
          centreindex--;
        }
        leftindex = (startindex + startindex + centreindex) / 3;
        rightindex = (centreindex + endindex + endindex) / 3;
        leftcoord = (xcoords[startindex] * 2 + xcoords[centreindex]) / 3.0;
        rightcoord = (xcoords[centreindex] + xcoords[endindex] * 2) / 3.0;
        while (xcoords[leftindex] > leftcoord &&
               leftindex - startindex > textord_spline_medianwin) {
          leftindex--;
        }
        while (xcoords[leftindex] < leftcoord &&
               centreindex - leftindex > textord_spline_medianwin / 2) {
          leftindex++;
        }
        if (xcoords[leftindex] - leftcoord > leftcoord - xcoords[leftindex - 1]) {
          leftindex--;
        }
        while (xcoords[rightindex] > rightcoord &&
               rightindex - centreindex > textord_spline_medianwin / 2) {
          rightindex--;
        }
        while (xcoords[rightindex] < rightcoord &&
               endindex - rightindex > textord_spline_medianwin) {
          rightindex++;
        }
        if (xcoords[rightindex] - rightcoord > rightcoord - xcoords[rightindex - 1]) {
          rightindex--;
        }
        if (textord_debug_baselines) {
          tprintf(""Splitting spline at %d with step %g at (%d,%d)\\n"", xstarts[segment],
                  baseline->step((xstarts[segment - 1] + xstarts[segment]) / 2.0,
                                 (xstarts[segment] + xstarts[segment + 1]) / 2.0),
                  (xcoords[leftindex - 1] + xcoords[leftindex]) / 2,
                  (xcoords[rightindex - 1] + xcoords[rightindex]) / 2);
        }
        insert_spline_point(xstarts, segment, (xcoords[leftindex - 1] + xcoords[leftindex]) / 2,
                            (xcoords[rightindex - 1] + xcoords[rightindex]) / 2, segments);
        doneany = true;
      } else if (textord_debug_baselines) {
        tprintf(""Resegmenting spline failed - insufficient pts (%d,%d,%d,%d)\\n"", startindex,
                centreindex, endindex, (int32_t)textord_spline_medianwin);
      }
    }
    //              else tprintf(""Spline step at %d is %g\\n"",
    //                      xstarts[segment],
    //                      baseline->step((xstarts[segment-1]+xstarts[segment])/2.0,
    //                      (xstarts[segment]+xstarts[segment+1])/2.0));
  }
  return doneany;
}

/**********************************************************************
 * insert_spline_point
 *
 * Insert a new spline point and shuffle up the others.
 **********************************************************************/

void insert_spline_point(     // get descenders
    int xstarts[],            // starts to shuffle
    int segment,              // insertion pt
    int coord1,               // coords to add
    int coord2, int &segments // total segments
) {
  int index; // for shuffling

  for (index = segments; index > segment; index--) {
    xstarts[index + 1] = xstarts[index];
  }
  segments++;
  xstarts[segment] = coord1;
  xstarts[segment + 1] = coord2;
}

/**********************************************************************
 * find_lesser_parts
 *
 * Average the step from the spline for the other partitions
 * and find the commonest partition which has a descender.
 **********************************************************************/

void find_lesser_parts( // get descenders
    TO_ROW *row,        // row to process
    TBOX blobcoords[],  // bounding boxes
    int blobcount,      /*no of blobs */
    char partids[],     /*partition of each blob */
    int partsizes[],    /*size of each part */
    int partcount,      /*no of partitions */
    int bestpart        /*biggest partition */
) {
  int blobindex;             /*index of blob */
  int partition;             /*current partition */
  int xcentre;               /*centre of blob */
  int poscount;              /*count of best up step */
  int negcount;              /*count of best down step */
  float partsteps[MAXPARTS]; /*average step to part */
  float bestneg;             /*best down step */
  int runlength;             /*length of bad run */
  int biggestrun;            /*biggest bad run */

  biggestrun = 0;
  for (partition = 0; partition < partcount; partition++) {
    partsteps[partition] = 0.0; /*zero accumulators */
  }
  for (runlength = 0, blobindex = 0; blobindex < blobcount; blobindex++) {
    xcentre = (blobcoords[blobindex].left() + blobcoords[blobindex].right()) >> 1;
    /*in other parts */
    int part_id = static_cast<int>(static_cast<unsigned char>(partids[blobindex]));
    if (part_id != bestpart) {
      runlength++; /*run of non bests */
      if (runlength > biggestrun) {
        biggestrun = runlength;
      }
      partsteps[part_id] += blobcoords[blobindex].bottom() - row->baseline.y(xcentre);
    } else {
      runlength = 0;
    }
  }
  if (biggestrun > MAXBADRUN) {
    row->xheight = -1.0f; /*failed */
  } else {
    row->xheight = 1.0f; /*success */
  }
  poscount = negcount = 0;
  bestneg = 0.0; /*no step yet */
  for (partition = 0; partition < partcount; partition++) {
    if (partition != bestpart) {
      // by jetsoft divide by zero possible
      if (partsizes[partition] == 0) {
        partsteps[partition] = 0;
      } else {
        partsteps[partition] /= partsizes[partition];
      }
      //

      if (partsteps[partition] >= MINASCRISE && partsizes[partition] > poscount) {
        poscount = partsizes[partition];
      }
      if (partsteps[partition] <= -MINASCRISE && partsizes[partition] > negcount) {
        /*ascender rise */
        bestneg = partsteps[partition];
        /*2nd most popular */
        negcount = partsizes[partition];
      }
    }
  }
  /*average x-height */
  partsteps[bestpart] /= blobcount;
  row->descdrop = bestneg;
}

/**********************************************************************
 * old_first_xheight
 *
 * Makes an x-height spline by copying the baseline and shifting it.
 * It estimates the x-height across the line to use as the shift.
 * It also finds the ascender height if it can.
 **********************************************************************/

void old_first_xheight( // the wiseowl way
    TO_ROW *row,        /*current row */
    TBOX blobcoords[],  /*blob bounding boxes */
    int initialheight,  // initial guess
    int blobcount,      /*blobs in blobcoords */
    QSPLINE *baseline,  /*established */
    float jumplimit     /*min ascender height */
) {
  int blobindex; /*current blob */
                 /*height statistics */
  STATS heightstat(0, MAXHEIGHT);
  int height;      /*height of blob */
  int xcentre;     /*centre of blob */
  int lineheight;  /*approx xheight */
  float ascenders; /*ascender sum */
  int asccount;    /*no of ascenders */
  float xsum;      /*xheight sum */
  int xcount;      /*xheight count */
  float diff;      /*height difference */

  if (blobcount > 1) {
    for (blobindex = 0; blobindex < blobcount; blobindex++) {
      xcentre = (blobcoords[blobindex].left() + blobcoords[blobindex].right()) / 2;
      /*height of blob */
      height = static_cast<int>(blobcoords[blobindex].top() - baseline->y(xcentre) + 0.5);
      if (height > initialheight * oldbl_xhfract && height > textord_min_xheight) {
        heightstat.add(height, 1);
      }
    }
    if (heightstat.get_total() > 3) {
      lineheight = static_cast<int>(heightstat.ile(0.25));
      if (lineheight <= 0) {
        lineheight = static_cast<int>(heightstat.ile(0.5));
      }
    } else {
      lineheight = initialheight;
    }
  } else {
    lineheight =
        static_cast<int>(blobcoords[0].top() -
                         baseline->y((blobcoords[0].left() + blobcoords[0].right()) / 2) + 0.5);
  }

  xsum = 0.0f;
  xcount = 0;
  for (ascenders = 0.0f, asccount = 0, blobindex = 0; blobindex < blobcount; blobindex++) {
    xcentre = (blobcoords[blobindex].left() + blobcoords[blobindex].right()) / 2;
    diff = blobcoords[blobindex].top() - baseline->y(xcentre);
    /*is it ascender */
    if (diff > lineheight + jumplimit) {
      ascenders += diff;
      asccount++; /*count ascenders */
    } else if (diff > lineheight - jumplimit) {
      xsum += diff; /*mean xheight */
      xcount++;
    }
  }
  if (xcount > 0) {
    xsum /= xcount; /*average xheight */
  } else {
    xsum = static_cast<float>(lineheight); /*guess it */
  }
  row->xheight *= xsum;
  if (asccount > 0) {
    row->ascrise = ascenders / asccount - xsum;
  } else {
    row->ascrise = 0.0f; /*had none */
  }
  if (row->xheight == 0) {
    row->xheight = -1.0f;
  }
}

/**********************************************************************
 * make_first_xheight
 *
 * Makes an x-height spline by copying the baseline and shifting it.
 * It estimates the x-height across the line to use as the shift.
 * It also finds the ascender height if it can.
 **********************************************************************/

void make_first_xheight( // find xheight
    TO_ROW *row,         /*current row */
    TBOX blobcoords[],   /*blob bounding boxes */
    int lineheight,      // initial guess
    int init_lineheight, // block level guess
    int blobcount,       /*blobs in blobcoords */
    QSPLINE *baseline,   /*established */
    float jumplimit      /*min ascender height */
) {
  STATS heightstat(0, HEIGHTBUCKETS);
  int lefts[HEIGHTBUCKETS];
  int rights[HEIGHTBUCKETS];
  int modelist[MODENUM];
  int blobindex;
  int mode_count; // blobs to count in thr
  int sign_bit;
  int mode_threshold;
  const int kBaselineTouch = 2;  // This really should change with resolution.
  const int kGoodStrength = 8;   // Strength of baseline-touching heights.
  const float kMinHeight = 0.25; // Min fraction of lineheight to use.

  sign_bit = row->xheight > 0 ? 1 : -1;

  memset(lefts, 0, HEIGHTBUCKETS * sizeof(lefts[0]));
  memset(rights, 0, HEIGHTBUCKETS * sizeof(rights[0]));
  mode_count = 0;
  for (blobindex = 0; blobindex < blobcount; blobindex++) {
    int xcenter = (blobcoords[blobindex].left() + blobcoords[blobindex].right()) / 2;
    float base = baseline->y(xcenter);
    float bottomdiff = std::fabs(base - blobcoords[blobindex].bottom());
    int strength = textord_ocropus_mode && bottomdiff <= kBaselineTouch ? kGoodStrength : 1;
    int height = static_cast<int>(blobcoords[blobindex].top() - base + 0.5);
    if (blobcoords[blobindex].height() > init_lineheight * kMinHeight) {
      if (height > lineheight * oldbl_xhfract && height > textord_min_xheight) {
        heightstat.add(height, strength);
        if (height < HEIGHTBUCKETS) {
          if (xcenter > rights[height]) {
            rights[height] = xcenter;
          }
          if (xcenter > 0 && (lefts[height] == 0 || xcenter < lefts[height])) {
            lefts[height] = xcenter;
          }
        }
      }
      mode_count += strength;
    }
  }

  mode_threshold = static_cast<int>(blobcount * 0.1);
  if (oldbl_dot_error_size > 1 || oldbl_xhfix) {
    mode_threshold = static_cast<int>(mode_count * 0.1);
  }

  if (textord_oldbl_debug) {
    tprintf(""blobcount=%d, mode_count=%d, mode_t=%d\\n"", blobcount, mode_count, mode_threshold);
  }
  find_top_modes(&heightstat, HEIGHTBUCKETS, modelist, MODENUM);
  if (textord_oldbl_debug) {
    for (blobindex = 0; blobindex < MODENUM; blobindex++) {
      tprintf(""mode[%d]=%d "", blobindex, modelist[blobindex]);
    }
    tprintf(""\\n"");
  }
  pick_x_height(row, modelist, lefts, rights, &heightstat, mode_threshold);

  if (textord_oldbl_debug) {
    tprintf(""Output xheight=%g\\n"", row->xheight);
  }
  if (row->xheight < 0 && textord_oldbl_debug) {
    tprintf(""WARNING: Row Line height < 0; %4.2f\\n"", row->xheight);
  }

  if (sign_bit < 0) {
    row->xheight = -row->xheight;
  }
}

/**********************************************************************
 * find_top_modes
 *
 * Fill the input array with the indices of the top ten modes of the
 * input distribution.
 **********************************************************************/

const int kMinModeFactorOcropus = 32;
const int kMinModeFactor = 12;

void find_top_modes(            // get modes
    STATS *stats,               // stats to hack
    int statnum,                // no of piles
    int modelist[], int modenum // no of modes to get
) {
  int mode_count;
  int last_i = 0;
  int last_max = INT32_MAX;
  int i;
  int mode;
  int total_max = 0;
  int mode_factor = textord_ocropus_mode ? kMinModeFactorOcropus : kMinModeFactor;

  for (mode_count = 0; mode_count < modenum; mode_count++) {
    mode = 0;
    for (i = 0; i < statnum; i++) {
      if (stats->pile_count(i) > stats->pile_count(mode)) {
        if ((stats->pile_count(i) < last_max) ||
            ((stats->pile_count(i) == last_max) && (i > last_i))) {
          mode = i;
        }
      }
    }
    last_i = mode;
    last_max = stats->pile_count(last_i);
    total_max += last_max;
    if (last_max <= total_max / mode_factor) {
      mode = 0;
    }
    modelist[mode_count] = mode;
  }
}

/**********************************************************************
 * pick_x_height
 *
 * Choose based on the height modes the best x height value.
 **********************************************************************/

void pick_x_height(TO_ROW *row, // row to do
                   int modelist[], int lefts[], int rights[], STATS *heightstat,
                   int mode_threshold) {
  int x;
  int y;
  int z;
  float ratio;
  int found_one_bigger = false;
  int best_x_height = 0;
  int best_asc = 0;
  int num_in_best;

  for (x = 0; x < MODENUM; x++) {
    for (y = 0; y < MODENUM; y++) {
      /* Check for two modes */
      if (modelist[x] && modelist[y] && heightstat->pile_count(modelist[x]) > mode_threshold &&
          (!textord_ocropus_mode || std::min(rights[modelist[x]], rights[modelist[y]]) >
                                        std::max(lefts[modelist[x]], lefts[modelist[y]]))) {
        ratio = static_cast<float>(modelist[y]) / static_cast<float>(modelist[x]);
        if (1.2 < ratio && ratio < 1.8) {
          /* Two modes found */
          best_x_height = modelist[x];
          num_in_best = heightstat->pile_count(modelist[x]);

          /* Try to get one higher */
          do {
            found_one_bigger = false;
            for (z = 0; z < MODENUM; z++) {
              if (modelist[z] == best_x_height + 1 &&
                  (!textord_ocropus_mode || std::min(rights[modelist[x]], rights[modelist[y]]) >
                                                std::max(lefts[modelist[x]], lefts[modelist[y]]))) {
                ratio = static_cast<float>(modelist[y]) / static_cast<float>(modelist[z]);
                if ((1.2 < ratio && ratio < 1.8) &&
                    /* Should be half of best */
                    heightstat->pile_count(modelist[z]) > num_in_best * 0.5) {
                  best_x_height++;
                  found_one_bigger = true;
                  break;
                }
              }
            }
          } while (found_one_bigger);

          /* try to get a higher ascender */

          best_asc = modelist[y];
          num_in_best = heightstat->pile_count(modelist[y]);

          /* Try to get one higher */
          do {
            found_one_bigger = false;
            for (z = 0; z < MODENUM; z++) {
              if (modelist[z] > best_asc &&
                  (!textord_ocropus_mode || std::min(rights[modelist[x]], rights[modelist[y]]) >
                                                std::max(lefts[modelist[x]], lefts[modelist[y]]))) {
                ratio = static_cast<float>(modelist[z]) / static_cast<float>(best_x_height);
                if ((1.2 < ratio && ratio < 1.8) &&
                    /* Should be half of best */
                    heightstat->pile_count(modelist[z]) > num_in_best * 0.5) {
                  best_asc = modelist[z];
                  found_one_bigger = true;
                  break;
                }
              }
            }
          } while (found_one_bigger);

          row->xheight = static_cast<float>(best_x_height);
          row->ascrise = static_cast<float>(best_asc) - best_x_height;
          return;
        }
      }
    }
  }

  best_x_height = modelist[0]; /* Single Mode found */
  num_in_best = heightstat->pile_count(best_x_height);
  do {
    /* Try to get one higher */
    found_one_bigger = false;
    for (z = 1; z < MODENUM; z++) {
      /* Should be half of best */
      if ((modelist[z] == best_x_height + 1) &&
          (heightstat->pile_count(modelist[z]) > num_in_best * 0.5)) {
        best_x_height++;
        found_one_bigger = true;
        break;
      }
    }
  } while (found_one_bigger);

  row->ascrise = 0.0f;
  row->xheight = static_cast<float>(best_x_height);
  if (row->xheight == 0) {
    row->xheight = -1.0f;
  }
}

} // namespace tesseract
",16177,True,2975.6180332857184,median
"[[netty-component]]
= Netty Component
:docTitle: Netty
:artifactId: camel-netty
:description: Socket level networking using TCP or UDP with the Netty 4.x.
:since: 2.14
:supportLevel: Stable
:component-header: Both producer and consumer are supported

*Since Camel {since}*

*{component-header}*

The Netty component in Camel is a socket communication component,
based on the http://netty.io/[Netty] project version 4. +
 Netty is a NIO client server framework which enables quick and easy
development of networkServerInitializerFactory applications such as
protocol servers and clients. +
 Netty greatly simplifies and streamlines network programming such as
TCP and UDP socket server.

This camel component supports both producer and consumer endpoints.

The Netty component has several options and allows fine-grained control
of a number of TCP/UDP communication parameters (buffer sizes,
keepAlives, tcpNoDelay, etc) and facilitates both In-Only and In-Out
communication on a Camel route.

Maven users will need to add the following dependency to their `pom.xml`
for this component:

[source,xml]
----
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-netty</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
----

== URI format

The URI scheme for a netty component is as follows

[source,text]
----
netty:tcp://0.0.0.0:99999[?options]
netty:udp://remotehost:99999/[?options]
----

This component supports producer and consumer endpoints for both TCP and
UDP.

You can append query options to the URI in the following format,
`?option=value&option=value&...`

== Options

// component options: START
The Netty component supports 72 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *configuration* (common) | To use the NettyConfiguration as configuration when creating endpoints. |  | NettyConfiguration
| *disconnect* (common) | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. | false | boolean
| *keepAlive* (common) | Setting to ensure socket is not closed due to inactivity | true | boolean
| *reuseAddress* (common) | Setting to facilitate socket multiplexing | true | boolean
| *reuseChannel* (common) | This option allows producers and consumers (in client mode) to reuse the same Netty Channel for the lifecycle of processing the Exchange. This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection. When using this, the channel is not returned to the connection pool until the Exchange is done; or disconnected if the disconnect option is set to true. The reused Channel is stored on the Exchange as an exchange property with the key NettyConstants#NETTY_CHANNEL which allows you to obtain the channel during routing and use it as well. | false | boolean
| *sync* (common) | Setting to set endpoint as one-way or request-response | true | boolean
| *tcpNoDelay* (common) | Setting to improve TCP protocol performance | true | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *broadcast* (consumer) | Setting to choose Multicast over UDP | false | boolean
| *clientMode* (consumer) | If the clientMode is true, netty consumer will connect the address as a TCP client. | false | boolean
| *reconnect* (consumer) | Used only in clientMode in consumer, the consumer will attempt to reconnect on disconnection if this is enabled | true | boolean
| *reconnectInterval* (consumer) | Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection | 10000 | int
| *backlog* (consumer) | Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200, 500 or 1000, tells the TCP stack how long the accept queue can be If this option is not configured, then the backlog depends on OS setting. |  | int
| *bossCount* (consumer) | When netty works on nio mode, it uses default bossCount parameter from Netty, which is 1. User can use this option to override the default bossCount from Netty | 1 | int
| *bossGroup* (consumer) | Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint |  | EventLoopGroup
| *disconnectOnNoReply* (consumer) | If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back. | true | boolean
| *executorService* (consumer) | To use the given EventExecutorGroup. |  | EventExecutorGroup
| *maximumPoolSize* (consumer) | Sets a maximum thread pool size for the netty consumer ordered thread pool. The default size is 2 x cpu_core plus 1. Setting this value to eg 10 will then use 10 threads unless 2 x cpu_core plus 1 is a higher value, which then will override and be used. For example if there are 8 cores, then the consumer thread pool will be 17. This thread pool is used to route messages received from Netty by Camel. We use a separate thread pool to ensure ordering of messages and also in case some messages will block, then nettys worker threads (event loop) wont be affected. |  | int
| *nettyServerBootstrapFactory* (consumer) | To use a custom NettyServerBootstrapFactory |  | NettyServerBootstrapFactory
| *networkInterface* (consumer) | When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group. |  | String
| *noReplyLogLevel* (consumer) | If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverClosedChannelException{zwsp}CaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | DEBUG | LoggingLevel
| *serverExceptionCaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an exception then its logged using this logging level. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverInitializerFactory* (consumer) | To use a custom ServerInitializerFactory |  | ServerInitializerFactory
| *usingExecutorService* (consumer) | Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. | true | boolean
| *connectTimeout* (producer) | Time to wait for a socket connection to be available. Value is in milliseconds. | 10000 | int
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *requestTimeout* (producer) | Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milli seconds, so eg 30000 is 30 seconds. The requestTimeout is using Netty's ReadTimeoutHandler to trigger the timeout. |  | long
| *clientInitializerFactory* (producer) | To use a custom ClientInitializerFactory |  | ClientInitializerFactory
| *correlationManager* (producer) | To use a custom correlation manager to manage how request and reply messages are mapped when using request/reply with the netty producer. This should only be used if you have a way to map requests together with replies such as if there is correlation ids in both the request and reply messages. This can be used if you want to multiplex concurrent messages on the same channel (aka connection) in netty. When doing this you must have a way to correlate the request and reply messages so you can store the right reply on the inflight Camel Exchange before its continued routed. We recommend extending the TimeoutCorrelationManagerSupport when you build custom correlation managers. This provides support for timeout and other complexities you otherwise would need to implement as well. See also the producerPoolEnabled option for more details. |  | NettyCamelStateCorrelationManager
| *lazyChannelCreation* (producer) | Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. | true | boolean
| *producerPoolEnabled* (producer) | Whether producer pool is enabled or not. Important: If you turn this off then a single shared connection is used for the producer, also if you are doing request/reply. That means there is a potential issue with interleaved responses if replies comes back out-of-order. Therefore you need to have a correlation id in both the request and reply messages so you can properly correlate the replies to the Camel callback that is responsible for continue processing the message in Camel. To do this you need to implement NettyCamelStateCorrelationManager as correlation manager and configure it via the correlationManager option. See also the correlationManager option for more details. | true | boolean
| *producerPoolMaxActive* (producer) | Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit. | -1 | int
| *producerPoolMaxIdle* (producer) | Sets the cap on the number of idle instances in the pool. | 100 | int
| *producerPoolMinEvictableIdle* (producer) | Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor. | 300000 | long
| *producerPoolMinIdle* (producer) | Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects. |  | int
| *udpConnectionlessSending* (producer) | This option supports connection less udp sending which is a real fire and forget. A connected udp send receive the PortUnreachableException if no one is listen on the receiving port. | false | boolean
| *useByteBuf* (producer) | If the useByteBuf is true, netty producer will turn the message body into ByteBuf before sending it out. | false | boolean
| *allowSerializedHeaders* (advanced) | Only used for TCP when transferExchange is true. When set to true, serializable objects in headers and properties will be added to the exchange. Otherwise Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *basicPropertyBinding* (advanced) | *Deprecated* Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
| *channelGroup* (advanced) | To use a explicit ChannelGroup. |  | ChannelGroup
| *nativeTransport* (advanced) | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: \\http://netty.io/wiki/native-transports.html | false | boolean
| *options* (advanced) | Allows to configure additional netty options using option. as prefix. For example option.child.keepAlive=false to set the netty option child.keepAlive=false. See the Netty documentation for possible options that can be used. |  | Map
| *receiveBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. | 65536 | int
| *receiveBufferSizePredictor* (advanced) | Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |  | int
| *sendBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. | 65536 | int
| *transferExchange* (advanced) | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *udpByteArrayCodec* (advanced) | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | boolean
| *workerCount* (advanced) | When netty works on nio mode, it uses default workerCount parameter from Netty (which is cpu_core_threads x 2). User can use this option to override the default workerCount from Netty. |  | int
| *workerGroup* (advanced) | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. |  | EventLoopGroup
| *allowDefaultCodec* (codec) | The netty component installs a default codec if both, encoder/decoder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | boolean
| *autoAppendDelimiter* (codec) | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | boolean
| *decoderMaxLineLength* (codec) | The max line length to use for the textline codec. | 1024 | int
| *decoders* (codec) | A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *delimiter* (codec) | The delimiter to use for the textline codec. Possible values are LINE and NULL. There are 2 enums and the value can be one of: LINE, NULL | LINE | TextLineDelimiter
| *encoders* (codec) | A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *encoding* (codec) | The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |  | String
| *textline* (codec) | Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP - however only Strings are allowed to be serialized by default. | false | boolean
| *enabledProtocols* (security) | Which protocols to enable when using SSL | TLSv1,TLSv1.1,TLSv1.2 | String
| *keyStoreFile* (security) | Client side certificate keystore to be used for encryption |  | File
| *keyStoreFormat* (security) | Keystore format to be used for payload encryption. Defaults to JKS if not set |  | String
| *keyStoreResource* (security) | Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *needClientAuth* (security) | Configures whether the server needs client authentication when using SSL. | false | boolean
| *passphrase* (security) | Password setting to use in order to encrypt/decrypt payloads sent using SSH |  | String
| *securityProvider* (security) | Security provider to be used for payload encryption. Defaults to SunX509 if not set. |  | String
| *ssl* (security) | Setting to specify whether SSL encryption is applied to this endpoint | false | boolean
| *sslClientCertHeaders* (security) | When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. | false | boolean
| *sslContextParameters* (security) | To configure security using SSLContextParameters |  | SSLContextParameters
| *sslHandler* (security) | Reference to a class that could be used to return an SSL Handler |  | SslHandler
| *trustStoreFile* (security) | Server side certificate keystore to be used for encryption |  | File
| *trustStoreResource* (security) | Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *useGlobalSslContextParameters* (security) | Enable usage of global SSL context parameters. | false | boolean
|===
// component options: END


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

----
netty:protocol:host:port
----

with the following path and query parameters:

=== Path Parameters (3 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *protocol* | *Required* The protocol to use which can be tcp or udp. There are 2 enums and the value can be one of: tcp, udp |  | String
| *host* | *Required* The hostname. For the consumer the hostname is localhost or 0.0.0.0. For the producer the hostname is the remote host to connect to |  | String
| *port* | *Required* The host port number |  | int
|===


=== Query Parameters (71 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *disconnect* (common) | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. | false | boolean
| *keepAlive* (common) | Setting to ensure socket is not closed due to inactivity | true | boolean
| *reuseAddress* (common) | Setting to facilitate socket multiplexing | true | boolean
| *reuseChannel* (common) | This option allows producers and consumers (in client mode) to reuse the same Netty Channel for the lifecycle of processing the Exchange. This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection. When using this, the channel is not returned to the connection pool until the Exchange is done; or disconnected if the disconnect option is set to true. The reused Channel is stored on the Exchange as an exchange property with the key NettyConstants#NETTY_CHANNEL which allows you to obtain the channel during routing and use it as well. | false | boolean
| *sync* (common) | Setting to set endpoint as one-way or request-response | true | boolean
| *tcpNoDelay* (common) | Setting to improve TCP protocol performance | true | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *broadcast* (consumer) | Setting to choose Multicast over UDP | false | boolean
| *clientMode* (consumer) | If the clientMode is true, netty consumer will connect the address as a TCP client. | false | boolean
| *reconnect* (consumer) | Used only in clientMode in consumer, the consumer will attempt to reconnect on disconnection if this is enabled | true | boolean
| *reconnectInterval* (consumer) | Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection | 10000 | int
| *backlog* (consumer) | Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200, 500 or 1000, tells the TCP stack how long the accept queue can be If this option is not configured, then the backlog depends on OS setting. |  | int
| *bossCount* (consumer) | When netty works on nio mode, it uses default bossCount parameter from Netty, which is 1. User can use this option to override the default bossCount from Netty | 1 | int
| *bossGroup* (consumer) | Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint |  | EventLoopGroup
| *disconnectOnNoReply* (consumer) | If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back. | true | boolean
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut |  | ExchangePattern
| *nettyServerBootstrapFactory* (consumer) | To use a custom NettyServerBootstrapFactory |  | NettyServerBootstrapFactory
| *networkInterface* (consumer) | When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group. |  | String
| *noReplyLogLevel* (consumer) | If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverClosedChannelException{zwsp}CaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | DEBUG | LoggingLevel
| *serverExceptionCaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an exception then its logged using this logging level. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverInitializerFactory* (consumer) | To use a custom ServerInitializerFactory |  | ServerInitializerFactory
| *usingExecutorService* (consumer) | Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. | true | boolean
| *connectTimeout* (producer) | Time to wait for a socket connection to be available. Value is in milliseconds. | 10000 | int
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *requestTimeout* (producer) | Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milli seconds, so eg 30000 is 30 seconds. The requestTimeout is using Netty's ReadTimeoutHandler to trigger the timeout. |  | long
| *clientInitializerFactory* (producer) | To use a custom ClientInitializerFactory |  | ClientInitializerFactory
| *correlationManager* (producer) | To use a custom correlation manager to manage how request and reply messages are mapped when using request/reply with the netty producer. This should only be used if you have a way to map requests together with replies such as if there is correlation ids in both the request and reply messages. This can be used if you want to multiplex concurrent messages on the same channel (aka connection) in netty. When doing this you must have a way to correlate the request and reply messages so you can store the right reply on the inflight Camel Exchange before its continued routed. We recommend extending the TimeoutCorrelationManagerSupport when you build custom correlation managers. This provides support for timeout and other complexities you otherwise would need to implement as well. See also the producerPoolEnabled option for more details. |  | NettyCamelStateCorrelationManager
| *lazyChannelCreation* (producer) | Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. | true | boolean
| *producerPoolEnabled* (producer) | Whether producer pool is enabled or not. Important: If you turn this off then a single shared connection is used for the producer, also if you are doing request/reply. That means there is a potential issue with interleaved responses if replies comes back out-of-order. Therefore you need to have a correlation id in both the request and reply messages so you can properly correlate the replies to the Camel callback that is responsible for continue processing the message in Camel. To do this you need to implement NettyCamelStateCorrelationManager as correlation manager and configure it via the correlationManager option. See also the correlationManager option for more details. | true | boolean
| *producerPoolMaxActive* (producer) | Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit. | -1 | int
| *producerPoolMaxIdle* (producer) | Sets the cap on the number of idle instances in the pool. | 100 | int
| *producerPoolMinEvictableIdle* (producer) | Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor. | 300000 | long
| *producerPoolMinIdle* (producer) | Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects. |  | int
| *udpConnectionlessSending* (producer) | This option supports connection less udp sending which is a real fire and forget. A connected udp send receive the PortUnreachableException if no one is listen on the receiving port. | false | boolean
| *useByteBuf* (producer) | If the useByteBuf is true, netty producer will turn the message body into ByteBuf before sending it out. | false | boolean
| *allowSerializedHeaders* (advanced) | Only used for TCP when transferExchange is true. When set to true, serializable objects in headers and properties will be added to the exchange. Otherwise Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *basicPropertyBinding* (advanced) | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
| *channelGroup* (advanced) | To use a explicit ChannelGroup. |  | ChannelGroup
| *nativeTransport* (advanced) | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: \\http://netty.io/wiki/native-transports.html | false | boolean
| *options* (advanced) | Allows to configure additional netty options using option. as prefix. For example option.child.keepAlive=false to set the netty option child.keepAlive=false. See the Netty documentation for possible options that can be used. |  | Map
| *receiveBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. | 65536 | int
| *receiveBufferSizePredictor* (advanced) | Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |  | int
| *sendBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. | 65536 | int
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
| *transferExchange* (advanced) | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *udpByteArrayCodec* (advanced) | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | boolean
| *workerCount* (advanced) | When netty works on nio mode, it uses default workerCount parameter from Netty (which is cpu_core_threads x 2). User can use this option to override the default workerCount from Netty. |  | int
| *workerGroup* (advanced) | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. |  | EventLoopGroup
| *allowDefaultCodec* (codec) | The netty component installs a default codec if both, encoder/decoder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | boolean
| *autoAppendDelimiter* (codec) | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | boolean
| *decoderMaxLineLength* (codec) | The max line length to use for the textline codec. | 1024 | int
| *decoders* (codec) | A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *delimiter* (codec) | The delimiter to use for the textline codec. Possible values are LINE and NULL. There are 2 enums and the value can be one of: LINE, NULL | LINE | TextLineDelimiter
| *encoders* (codec) | A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *encoding* (codec) | The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |  | String
| *textline* (codec) | Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP - however only Strings are allowed to be serialized by default. | false | boolean
| *enabledProtocols* (security) | Which protocols to enable when using SSL | TLSv1,TLSv1.1,TLSv1.2 | String
| *keyStoreFile* (security) | Client side certificate keystore to be used for encryption |  | File
| *keyStoreFormat* (security) | Keystore format to be used for payload encryption. Defaults to JKS if not set |  | String
| *keyStoreResource* (security) | Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *needClientAuth* (security) | Configures whether the server needs client authentication when using SSL. | false | boolean
| *passphrase* (security) | Password setting to use in order to encrypt/decrypt payloads sent using SSH |  | String
| *securityProvider* (security) | Security provider to be used for payload encryption. Defaults to SunX509 if not set. |  | String
| *ssl* (security) | Setting to specify whether SSL encryption is applied to this endpoint | false | boolean
| *sslClientCertHeaders* (security) | When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. | false | boolean
| *sslContextParameters* (security) | To configure security using SSLContextParameters |  | SSLContextParameters
| *sslHandler* (security) | Reference to a class that could be used to return an SSL Handler |  | SslHandler
| *trustStoreFile* (security) | Server side certificate keystore to be used for encryption |  | File
| *trustStoreResource* (security) | Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
|===
// endpoint options: END



== Registry based Options

Codec Handlers and SSL Keystores can be enlisted in the Registry, such as in the Spring XML file.
The values that could be passed in, are the following:

[width=""100%"",cols=""10%,90%"",options=""header"",]
|===
|Name |Description

|`passphrase` |password setting to use in order to encrypt/decrypt payloads sent using
SSH

|`keyStoreFormat` |keystore format to be used for payload encryption. Defaults to ""JKS"" if
not set

|`securityProvider` |Security provider to be used for payload encryption. Defaults to
""SunX509"" if not set.

|`keyStoreFile` |*deprecated:* Client side certificate keystore to be used for encryption

|`trustStoreFile` |*deprecated:* Server side certificate keystore to be used for encryption

|`keyStoreResource` |Client side certificate keystore to be used for
encryption. Is loaded by default from classpath, but you can prefix with
`""classpath:""`, `""file:""`, or `""http:""` to load the resource from
different systems.

|`trustStoreResource` |Server side certificate keystore to be used for
encryption. Is loaded by default from classpath, but you can prefix with
`""classpath:""`, `""file:""`, or `""http:""` to load the resource from
different systems.

|`sslHandler` |Reference to a class that could be used to return an SSL Handler

|`encoder` |A custom `ChannelHandler` class that can be used to perform special
marshalling of outbound payloads. Must override
io.netty.channel.ChannelInboundHandlerAdapter.

|`encoders` |A list of encoders to be used. You can use a String which have values
separated by comma, and have the values be looked up in the
Registry. Just remember to prefix the value with #
so Camel knows it should lookup.

|`decoder` |A custom `ChannelHandler` class that can be used to perform special
marshalling of inbound payloads. Must override
io.netty.channel.ChannelOutboundHandlerAdapter.

|`decoders` |A list of decoders to be used. You can use a String which have values
separated by comma, and have the values be looked up in the
Registry. Just remember to prefix the value with #
so Camel knows it should lookup.
|===

[NOTE]
====
Read below about using non shareable encoders/decoders.
====

=== Using non shareable encoders or decoders

If your encoders or decoders are not shareable (e.g. they don't have the
@Shareable class annotation), then your encoder/decoder must implement
the `org.apache.camel.component.netty.ChannelHandlerFactory` interface,
and return a new instance in the `newChannelHandler` method. This is to
ensure the encoder/decoder can safely be used. If this is not the case,
then the Netty component will log a WARN when an endpoint is created.

The Netty component offers a
`org.apache.camel.component.netty.ChannelHandlerFactories` factory
class, that has a number of commonly used methods.

== Sending Messages to/from a Netty endpoint

=== Netty Producer

In Producer mode, the component provides the ability to send payloads to
a socket endpoint using either TCP or UDP protocols (with optional SSL support).

The producer mode supports both one-way and request-response based operations.

=== Netty Consumer

In Consumer mode, the component provides the ability to:

* listen on a specified socket using either TCP or UDP protocols (with
optional SSL support),
* receive requests on the socket using text/xml, binary and serialized
object based payloads and
* send them along on a route as message exchanges.

The consumer mode supports both one-way and request-response based
operations.

== Examples

=== A UDP Netty endpoint using Request-Reply and serialized object payload

Note that Object serialization is not allowed by default, and so a decoder must be configured.

[source,java]
----
@BindToRegistry(""decoder"")
public ChannelHandler getDecoder() throws Exception {
    return new DefaultChannelHandlerFactory() {
        @Override
        public ChannelHandler newChannelHandler() {
            return new DatagramPacketObjectDecoder(ClassResolvers.weakCachingResolver(null));
        }
    };
}

RouteBuilder builder = new RouteBuilder() {
  public void configure() {
    from(""netty:udp://0.0.0.0:5155?sync=true&decoders=#decoder"")
      .process(new Processor() {
         public void process(Exchange exchange) throws Exception {
           Poetry poetry = (Poetry) exchange.getIn().getBody();
           // Process poetry in some way
           exchange.getOut().setBody(""Message received);
         }
       }
    }
};
----

=== A TCP based Netty consumer endpoint using One-way communication

[source,java]
----
RouteBuilder builder = new RouteBuilder() {
  public void configure() {
       from(""netty:tcp://0.0.0.0:5150"")
           .to(""mock:result"");
  }
};
----

=== An SSL/TCP based Netty consumer endpoint using Request-Reply communication

[[Netty-UsingtheJSSEConfigurationUtility]]
Using the JSSE Configuration Utility

The Netty component supports SSL/TLS configuration
through the xref:manual::camel-configuration-utilities.adoc[Camel JSSE
Configuration Utility].  This utility greatly decreases the amount of
component specific code you need to write and is configurable at the
endpoint and component levels.  The following examples demonstrate how
to use the utility with the Netty component.

[[Netty-Programmaticconfigurationofthecomponent]]
Programmatic configuration of the component

[source,java]
----
KeyStoreParameters ksp = new KeyStoreParameters();
ksp.setResource(""/users/home/server/keystore.jks"");
ksp.setPassword(""keystorePassword"");

KeyManagersParameters kmp = new KeyManagersParameters();
kmp.setKeyStore(ksp);
kmp.setKeyPassword(""keyPassword"");

SSLContextParameters scp = new SSLContextParameters();
scp.setKeyManagers(kmp);

NettyComponent nettyComponent = getContext().getComponent(""netty"", NettyComponent.class);
nettyComponent.setSslContextParameters(scp);
----

[[Netty-SpringDSLbasedconfigurationofendpoint]]
Spring DSL based configuration of endpoint

[source,xml]
----
...
  <camel:sslContextParameters
      id=""sslContextParameters"">
    <camel:keyManagers
        keyPassword=""keyPassword"">
      <camel:keyStore
          resource=""/users/home/server/keystore.jks""
          password=""keystorePassword""/>
    </camel:keyManagers>
  </camel:sslContextParameters>...
...
  <to uri=""netty:tcp://0.0.0.0:5150?sync=true&ssl=true&sslContextParameters=#sslContextParameters""/>
...
----

[[Netty-UsingBasicSSLTLSconfigurationontheJettyComponent]]
Using Basic SSL/TLS configuration on the Jetty Component

[source,java]
----
Registry registry = context.getRegistry();
registry.bind(""password"", ""changeit"");
registry.bind(""ksf"", new File(""src/test/resources/keystore.jks""));
registry.bind(""tsf"", new File(""src/test/resources/keystore.jks""));

context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty:tcp://0.0.0.0:5150?sync=true&ssl=true&passphrase=#password""
         + ""&keyStoreFile=#ksf&trustStoreFile=#tsf"";
      String return_string =
         ""When You Go Home, Tell Them Of Us And Say,""
         + ""For Your Tomorrow, We Gave Our Today."";

      from(netty_ssl_endpoint)
       .process(new Processor() {
          public void process(Exchange exchange) throws Exception {
            exchange.getOut().setBody(return_string);
          }
       }
  }
});
----

[[Netty-GettingaccesstoSSLSessionandtheclientcertificate]]
Getting access to SSLSession and the client certificate

You can get access to the `javax.net.ssl.SSLSession` if you eg need to
get details about the client certificate. When `ssl=true` then the
xref:netty-component.adoc[Netty] component will store the `SSLSession` as a
header on the Camel Message as shown below:

[source,java]
----
SSLSession session = exchange.getIn().getHeader(NettyConstants.NETTY_SSL_SESSION, SSLSession.class);
// get the first certificate which is client certificate
javax.security.cert.X509Certificate cert = session.getPeerCertificateChain()[0];
Principal principal = cert.getSubjectDN();
----

Remember to set `needClientAuth=true` to authenticate the client,
otherwise `SSLSession` cannot access information about the client
certificate, and you may get an exception
`javax.net.ssl.SSLPeerUnverifiedException: peer not authenticated`. You
may also get this exception if the client certificate is expired or not
valid etc.

[TIP]
====
The option `sslClientCertHeaders` can be set to `true` which then
enriches the Camel Message with headers having
details about the client certificate. For example the subject name is
readily available in the header `CamelNettySSLClientCertSubjectName`.
====

=== Using Multiple Codecs

In certain cases it may be necessary to add chains of encoders and
decoders to the netty pipeline. To add multpile codecs to a camel netty
endpoint the 'encoders' and 'decoders' uri parameters should be used.
Like the 'encoder' and 'decoder' parameters they are used to supply
references (lists of ChannelUpstreamHandlers and
ChannelDownstreamHandlers) that should be added to the pipeline. Note
that if encoders is specified then the encoder param will be ignored,
similarly for decoders and the decoder param.

[NOTE]
====
Read further above about using non shareable encoders/decoders.
====

The lists of codecs need to be added to the Camel's registry so they can
be resolved when the endpoint is created.

[source,java]
----
ChannelHandlerFactory lengthDecoder = ChannelHandlerFactories.newLengthFieldBasedFrameDecoder(1048576, 0, 4, 0, 4);

StringDecoder stringDecoder = new StringDecoder();
registry.bind(""length-decoder"", lengthDecoder);
registry.bind(""string-decoder"", stringDecoder);

LengthFieldPrepender lengthEncoder = new LengthFieldPrepender(4);
StringEncoder stringEncoder = new StringEncoder();
registry.bind(""length-encoder"", lengthEncoder);
registry.bind(""string-encoder"", stringEncoder);

List<ChannelHandler> decoders = new ArrayList<ChannelHandler>();
decoders.add(lengthDecoder);
decoders.add(stringDecoder);

List<ChannelHandler> encoders = new ArrayList<ChannelHandler>();
encoders.add(lengthEncoder);
encoders.add(stringEncoder);

registry.bind(""encoders"", encoders);
registry.bind(""decoders"", decoders);
----

Spring's native collections support can be used to specify the codec
lists in an application context

[source,xml]
----
<util:list id=""decoders"" list-class=""java.util.LinkedList"">
        <bean class=""org.apache.camel.component.netty.ChannelHandlerFactories"" factory-method=""newLengthFieldBasedFrameDecoder"">
            <constructor-arg value=""1048576""/>
            <constructor-arg value=""0""/>
            <constructor-arg value=""4""/>
            <constructor-arg value=""0""/>
            <constructor-arg value=""4""/>
        </bean>
        <bean class=""io.netty.handler.codec.string.StringDecoder""/>
    </util:list>

    <util:list id=""encoders"" list-class=""java.util.LinkedList"">
        <bean class=""io.netty.handler.codec.LengthFieldPrepender"">
            <constructor-arg value=""4""/>
        </bean>
        <bean class=""io.netty.handler.codec.string.StringEncoder""/>
    </util:list>

    <bean id=""length-encoder"" class=""io.netty.handler.codec.LengthFieldPrepender"">
        <constructor-arg value=""4""/>
    </bean>
    <bean id=""string-encoder"" class=""io.netty.handler.codec.string.StringEncoder""/>

    <bean id=""length-decoder"" class=""org.apache.camel.component.netty.ChannelHandlerFactories"" factory-method=""newLengthFieldBasedFrameDecoder"">
        <constructor-arg value=""1048576""/>
        <constructor-arg value=""0""/>
        <constructor-arg value=""4""/>
        <constructor-arg value=""0""/>
        <constructor-arg value=""4""/>
    </bean>
    <bean id=""string-decoder"" class=""io.netty.handler.codec.string.StringDecoder""/>
----

The bean names can then be used in netty endpoint definitions either as
a comma separated list or contained in a List e.g.

[source,java]
----
 from(""direct:multiple-codec"").to(""netty:tcp://0.0.0.0:{{port}}?encoders=#encoders&sync=false"");

 from(""netty:tcp://0.0.0.0:{{port}}?decoders=#length-decoder,#string-decoder&sync=false"").to(""mock:multiple-codec"");
----

or via XML.

[source,xml]
----
<camelContext id=""multiple-netty-codecs-context"" xmlns=""http://camel.apache.org/schema/spring"">
    <route>
        <from uri=""direct:multiple-codec""/>
        <to uri=""netty:tcp://0.0.0.0:5150?encoders=#encoders&amp;sync=false""/>
    </route>
    <route>
        <from uri=""netty:tcp://0.0.0.0:5150?decoders=#length-decoder,#string-decoder&amp;sync=false""/>
        <to uri=""mock:multiple-codec""/>
    </route>
</camelContext>
----

== Closing Channel When Complete

When acting as a server you sometimes want to close the channel when,
for example, a client conversion is finished. +
 You can do this by simply setting the endpoint option
`disconnect=true`.

However you can also instruct Camel on a per message basis as follows. +
 To instruct Camel to close the channel, you should add a header with
the key `CamelNettyCloseChannelWhenComplete` set to a boolean `true`
value. +
 For instance, the example below will close the channel after it has
written the bye message back to the client:

[source,java]
----
from(""netty:tcp://0.0.0.0:8080"").process(new Processor() {
    public void process(Exchange exchange) throws Exception {
        String body = exchange.getIn().getBody(String.class);
        exchange.getOut().setBody(""Bye "" + body);
        // some condition which determines if we should close
        if (close) {
            exchange.getOut().setHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, true);
        }
    }
});
----

[[Netty-Addingcustomchannelpipelinefactoriestogaincompletecontroloveracreatedpipeline]]
Adding custom channel pipeline factories to gain complete control over a created pipeline

== Custom pipeline

Custom channel pipelines provide complete control to the user over the
handler/interceptor chain by inserting custom handler(s), encoder(s) &
decoder(s) without having to specify them in the Netty Endpoint URL in a
very simple way.

In order to add a custom pipeline, a custom channel pipeline factory
must be created and registered with the context via the context registry
(Registry, or the camel-spring ApplicationContextRegistry etc).

A custom pipeline factory must be constructed as follows

* A Producer linked channel pipeline factory must extend the abstract
class `ClientPipelineFactory`.
* A Consumer linked channel pipeline factory must extend the abstract
class `ServerInitializerFactory`.
* The classes should override the initChannel() method in order to
insert custom handler(s), encoder(s) and decoder(s). Not overriding the
`initChannel()` method creates a pipeline with no handlers, encoders or
decoders wired to the pipeline.

The example below shows how ServerInitializerFactory factory may be
created

=== Using custom pipeline factory

[source,java]
----
public class SampleServerInitializerFactory extends ServerInitializerFactory {
    private int maxLineSize = 1024;

    protected void initChannel(Channel ch) throws Exception {
        ChannelPipeline channelPipeline = ch.pipeline();

        channelPipeline.addLast(""encoder-SD"", new StringEncoder(CharsetUtil.UTF_8));
        channelPipeline.addLast(""decoder-DELIM"", new DelimiterBasedFrameDecoder(maxLineSize, true, Delimiters.lineDelimiter()));
        channelPipeline.addLast(""decoder-SD"", new StringDecoder(CharsetUtil.UTF_8));
        // here we add the default Camel ServerChannelHandler for the consumer, to allow Camel to route the message etc.
        channelPipeline.addLast(""handler"", new ServerChannelHandler(consumer));
    }
}
----

The custom channel pipeline factory can then be added to the registry
and instantiated/utilized on a camel route in the following way

[source,java]
----
Registry registry = camelContext.getRegistry();
ServerInitializerFactory factory = new TestServerInitializerFactory();
registry.bind(""spf"", factory);
context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty:tcp://0.0.0.0:5150?serverInitializerFactory=#spf""
      String return_string =
         ""When You Go Home, Tell Them Of Us And Say,""
         + ""For Your Tomorrow, We Gave Our Today."";

      from(netty_ssl_endpoint)
       .process(new Processor() {
          public void process(Exchange exchange) throws Exception {
            exchange.getOut().setBody(return_string);
          }
       }
  }
});
----

== Reusing Netty boss and worker thread pools

Netty has two kind of thread pools: boss and worker. By default each
Netty consumer and producer has their private thread pools. If you want
to reuse these thread pools among multiple consumers or producers then
the thread pools must be created and enlisted in the
Registry.

For example using Spring XML we can create a shared worker thread pool
using the `NettyWorkerPoolBuilder` with 2 worker threads as shown below:

[source,xml]
----
<!-- use the worker pool builder to help create the shared thread pool -->
<bean id=""poolBuilder"" class=""org.apache.camel.component.netty.NettyWorkerPoolBuilder"">
  <property name=""workerCount"" value=""2""/>
</bean>

<!-- the shared worker thread pool -->
<bean id=""sharedPool"" class=""org.jboss.netty.channel.socket.nio.WorkerPool""
      factory-bean=""poolBuilder"" factory-method=""build"" destroy-method=""shutdown"">
</bean>
----

[TIP]
====
For boss thread pool there is a
`org.apache.camel.component.netty.NettyServerBossPoolBuilder` builder
for Netty consumers, and a
`org.apache.camel.component.netty.NettyClientBossPoolBuilder` for the
Netty producers.
====

Then in the Camel routes we can refer to this worker pools by
configuring the `workerPool` option in the URI as shown below:

[source,xml]
----
<route>
  <from uri=""netty:tcp://0.0.0.0:5021?textline=true&amp;sync=true&amp;workerPool=#sharedPool&amp;usingExecutorService=false""/>
  <to uri=""log:result""/>
  ...
</route>
----

And if we have another route we can refer to the shared worker pool:

[source,xml]
----
<route>
  <from uri=""netty:tcp://0.0.0.0:5022?textline=true&amp;sync=true&amp;workerPool=#sharedPool&amp;usingExecutorService=false""/>
  <to uri=""log:result""/>
  ...
</route>
----

and so forth.

== Multiplexing concurrent messages over a single connection with request/reply

When using Netty for request/reply messaging via the netty producer then by default each
message is sent via a non-shared connection (pooled). This ensures that replies are
automatic being able to map to the correct request thread for further routing in Camel.
In other words correlation between request/reply messages happens out-of-the-box because
the replies comes back on the same connection that was used for sending the request;
and this connection is not shared with others. When the response comes back, the connection
is returned back to the connection pool, where it can be reused by others.

However if you want to multiplex concurrent request/responses on a single shared connection,
then you need to turn off the connection pooling by setting `producerPoolEnabled=false`.
Now this means there is a potential issue with interleaved responses if replies comes back out-of-order.
Therefore you need to have a correlation id in both the request and reply messages so you can properly
correlate the replies to the Camel callback that is responsible for continue processing the message in Camel.
To do this you need to implement `NettyCamelStateCorrelationManager` as correlation manager and configure
it via the `correlationManager=#myManager` option.

[NOTE]
====
We recommend extending the `TimeoutCorrelationManagerSupport` when you build custom correlation managers.
This provides support for timeout and other complexities you otherwise would need to implement as well.
====

You can find an example with the Apache Camel source code in the examples directory
under the `camel-example-netty-custom-correlation` directory.


include::camel-spring-boot::page$netty-starter.adoc[]
",12407,False,2350.6277116569645,median
"= v1.ServiceAccount
{product-author}
{product-version}
:data-uri:
:icons:
:toc: macro
:toc-title:
:toclevels: 2

toc::[]

== Description
[%hardbreaks]
ServiceAccount binds together: * a name, understood by users, and perhaps by peripheral systems, for an identity * a principal that can be authenticated and authorized * a set of secrets

== Object Schema
Expand or mouse-over a field for more information about it.

++++
<pre>
<div style=""margin-left:13px;""><span title=""(string) APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources"">apiVersion</span>:
</div><div style=""margin-left:13px;""><span title=""(boolean) AutomountServiceAccountToken indicates whether pods running as this service account should have an API token automatically mounted. Can be overridden at the pod level."">automountServiceAccountToken</span>:
</div><details><summary><span title=""(array) ImagePullSecrets is a list of references to secrets in the same namespace to use for pulling any images in pods that reference this ServiceAccount. ImagePullSecrets are distinct from Secrets because Secrets can be mounted in the pod, but ImagePullSecrets are only accessed by the kubelet. More info: https://kubernetes.io/docs/concepts/containers/images/#specifying-imagepullsecrets-on-a-pod"">imagePullSecrets</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string) Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names"">name</span>:
</div></details><div style=""margin-left:13px;""><span title=""(string) Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><details open><summary><span title=""(v1.ObjectMeta) Standard object&#39;s metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata"">metadata</span>:
</summary><details><summary>  <span title=""(object) Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations"">annotations</span>:
</summary><div style=""margin-left:13px;"">    <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) The name of the cluster which the object belongs to. This is used to distinguish resources with same name and namespace in different clusters. This field is not set anywhere right now and apiserver is going to ignore it if set in create or update request."">clusterName</span>:
</div><div style=""margin-left:13px;"">  <span title=""(v1.Time) CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.

Populated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata"">creationTimestamp</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only."">deletionGracePeriodSeconds</span>:
</div><div style=""margin-left:13px;"">  <span title=""(v1.Time) DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.

Populated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata"">deletionTimestamp</span>:
</div><details><summary>  <span title=""(array) Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed."">finalizers</span>:
</summary><div style=""margin-left:13px;"">  - <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.

If this field is specified and the generated name exists, the server will NOT return a 409 - instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, and the client should retry (optionally after the time indicated in the Retry-After header).

Applied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#idempotency"">generateName</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) A sequence number representing a specific generation of the desired state. Populated by the system. Read-only."">generation</span>:
</div><details><summary>  <span title=""(v1.Initializers) An initializer is a controller which enforces some system invariant at object creation time. This field is a list of initializers that have not yet acted on this object. If nil or empty, this object has been completely initialized. Otherwise, the object is considered uninitialized and is hidden (in list/watch and get calls) from clients that haven&#39;t explicitly asked to observe uninitialized objects.

When an object is created, the system will populate this list with the current set of initializers. Only privileged users may set or modify this list. Once it is empty, it may not be modified further by any user."">initializers</span>:
</summary><details><summary>    <span title=""(array) Pending is a list of initializers that must execute in order before this object is visible. When the last pending initializer is removed, and no failing result is set, the initializers struct will be set to nil and the object is considered as initialized and visible to all clients."">pending</span>:
</summary><div style=""margin-left:13px;"">    - <span title=""(string) name of the process that is responsible for initializing this object."">name</span>:
</div></details><details><summary>    <span title=""(v1.Status) If result is set with the Failure field, the object will be persisted to storage and then deleted, ensuring that other clients can observe the deletion."">result</span>:
</summary><div style=""margin-left:13px;"">      <span title=""(string) APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources"">apiVersion</span>:
</div><div style=""margin-left:13px;"">      <span title=""(integer) Suggested HTTP return code for this status, 0 if not set."">code</span>:
</div><details><summary>      <span title=""(v1.StatusDetails) Extended data associated with the reason.  Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type."">details</span>:
</summary><details><summary>        <span title=""(array) The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes."">causes</span>:
</summary><div style=""margin-left:13px;"">        - <span title=""(string) The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed.  Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.

Examples:
  &#34;name&#34; - the field &#34;name&#34; on the current resource
  &#34;items[0].name&#34; - the field &#34;name&#34; on the first array entry in &#34;items&#34;"">field</span>:
</div><div style=""margin-left:13px;"">          <span title=""(string) A human-readable description of the cause of the error.  This field may be presented as-is to a reader."">message</span>:
</div><div style=""margin-left:13px;"">          <span title=""(string) A machine-readable description of the cause of the error. If this value is empty there is no information available."">reason</span>:
</div></details><div style=""margin-left:13px;"">        <span title=""(string) The group attribute of the resource associated with the status StatusReason."">group</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described)."">name</span>:
</div><div style=""margin-left:13px;"">        <span title=""(integer) If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action."">retryAfterSeconds</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) UID of the resource. (when there is a single resource which can be described). More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><div style=""margin-left:13px;"">      <span title=""(string) Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">      <span title=""(string) A human-readable description of the status of this operation."">message</span>:
</div><details><summary>      <span title=""(v1.ListMeta) Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">metadata</span>:
</summary><div style=""margin-left:13px;"">        <span title=""(string) continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response."">continue</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) String that identifies the server&#39;s internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency"">resourceVersion</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) selfLink is a URL representing this object. Populated by the system. Read-only."">selfLink</span>:
</div></details><div style=""margin-left:13px;"">      <span title=""(string) A machine-readable description of why this operation is in the &#34;Failure&#34; status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it."">reason</span>:
</div><div style=""margin-left:13px;"">      <span title=""(string) Status of the operation. One of: &#34;Success&#34; or &#34;Failure&#34;. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#spec-and-status"">status</span>:
</div></details></details><details><summary>  <span title=""(object) Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels"">labels</span>:
</summary><div style=""margin-left:13px;"">    <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names"">name</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Namespace defines the space within each name must be unique. An empty namespace is equivalent to the &#34;default&#34; namespace, but &#34;default&#34; is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.

Must be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces"">namespace</span>:
</div><details><summary>  <span title=""(array) List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller."">ownerReferences</span>:
</summary><div style=""margin-left:13px;"">  - <span title=""(string) API version of the referent."">apiVersion</span>:
</div><div style=""margin-left:13px;"">    <span title=""(boolean) If true, AND if the owner has the &#34;foregroundDeletion&#34; finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. Defaults to false. To set this field, a user needs &#34;delete&#34; permission of the owner, otherwise 422 (Unprocessable Entity) will be returned."">blockOwnerDeletion</span>:
</div><div style=""margin-left:13px;"">    <span title=""(boolean) If true, this reference points to the managing controller."">controller</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names"">name</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.

Populated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency"">resourceVersion</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) SelfLink is a URL representing this object. Populated by the system. Read-only."">selfLink</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.

Populated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><details><summary><span title=""(array) Secrets is the list of secrets allowed to be used by pods running using this ServiceAccount. More info: https://kubernetes.io/docs/concepts/configuration/secret"">secrets</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string) API version of the referent."">apiVersion</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: &#34;spec.containers{name}&#34; (where &#34;name&#34; refers to the name of the container that triggered the event) or if no container name is specified &#34;spec.containers[2]&#34; (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object."">fieldPath</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names"">name</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/"">namespace</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency"">resourceVersion</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids"">uid</span>:
</div></details>
</pre>
++++

== Operations

[[Post-api-v1-serviceaccounts]]
=== Create a ServiceAccount
Create a ServiceAccount

==== HTTP request
----
POST /api/v1/serviceaccounts HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""ServiceAccount"",
  ""apiVersion"": ""v1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X POST \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/api/v1/serviceaccounts <<'EOF'
{
  ""kind"": ""ServiceAccount"",
  ""apiVersion"": ""v1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.ServiceAccount
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.ServiceAccount
|201 Created|v1.ServiceAccount
|202 Accepted|v1.ServiceAccount
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Post-api-v1-namespaces-namespace-serviceaccounts]]
=== Create a ServiceAccount in a namespace
Create a ServiceAccount

==== HTTP request
----
POST /api/v1/namespaces/$NAMESPACE/serviceaccounts HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""ServiceAccount"",
  ""apiVersion"": ""v1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X POST \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/api/v1/namespaces/$NAMESPACE/serviceaccounts <<'EOF'
{
  ""kind"": ""ServiceAccount"",
  ""apiVersion"": ""v1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.ServiceAccount
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.ServiceAccount
|201 Created|v1.ServiceAccount
|202 Accepted|v1.ServiceAccount
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Get-api-v1-namespaces-namespace-serviceaccounts-name]]
=== Get a ServiceAccount in a namespace
Read the specified ServiceAccount

==== HTTP request
----
GET /api/v1/namespaces/$NAMESPACE/serviceaccounts/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/api/v1/namespaces/$NAMESPACE/serviceaccounts/$NAME
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the ServiceAccount
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|exact|Should the export be exact.  Exact export maintains cluster-specific fields like 'Namespace'.
|export|Should this value be exported.  Export strips fields that a user can not specify.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.ServiceAccount
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Get-api-v1-serviceaccounts]]
=== Get all ServiceAccounts
List or watch objects of kind ServiceAccount

==== HTTP request
----
GET /api/v1/serviceaccounts HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/api/v1/serviceaccounts
----

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.ServiceAccountList
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-api-v1-namespaces-namespace-serviceaccounts]]
=== Get all ServiceAccounts in a namespace
List or watch objects of kind ServiceAccount

==== HTTP request
----
GET /api/v1/namespaces/$NAMESPACE/serviceaccounts HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/api/v1/namespaces/$NAMESPACE/serviceaccounts
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.ServiceAccountList
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-api-v1-watch-namespaces-namespace-serviceaccounts-name]]
=== Watch a ServiceAccount in a namespace
Watch changes to an object of kind ServiceAccount

==== HTTP request
----
GET /api/v1/watch/namespaces/$NAMESPACE/serviceaccounts/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/api/v1/watch/namespaces/$NAMESPACE/serviceaccounts/$NAME
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the ServiceAccount
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|pretty|If 'true', then the output is pretty printed.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.WatchEvent
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-api-v1-watch-serviceaccounts]]
=== Watch all ServiceAccounts
Watch individual changes to a list of ServiceAccount

==== HTTP request
----
GET /api/v1/watch/serviceaccounts HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/api/v1/watch/serviceaccounts
----

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|pretty|If 'true', then the output is pretty printed.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.WatchEvent
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-api-v1-watch-namespaces-namespace-serviceaccounts]]
=== Watch all ServiceAccounts in a namespace
Watch individual changes to a list of ServiceAccount

==== HTTP request
----
GET /api/v1/watch/namespaces/$NAMESPACE/serviceaccounts HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/api/v1/watch/namespaces/$NAMESPACE/serviceaccounts
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|pretty|If 'true', then the output is pretty printed.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.WatchEvent
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Put-api-v1-namespaces-namespace-serviceaccounts-name]]
=== Update a ServiceAccount in a namespace
Replace the specified ServiceAccount

==== HTTP request
----
PUT /api/v1/namespaces/$NAMESPACE/serviceaccounts/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""ServiceAccount"",
  ""apiVersion"": ""v1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X PUT \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/api/v1/namespaces/$NAMESPACE/serviceaccounts/$NAME <<'EOF'
{
  ""kind"": ""ServiceAccount"",
  ""apiVersion"": ""v1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.ServiceAccount
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the ServiceAccount
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.ServiceAccount
|201 Created|v1.ServiceAccount
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Patch-api-v1-namespaces-namespace-serviceaccounts-name]]
=== Patch a ServiceAccount in a namespace
Partially update the specified ServiceAccount

==== HTTP request
----
PATCH /api/v1/namespaces/$NAMESPACE/serviceaccounts/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json-patch+json'

{
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X PATCH \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json-patch+json' \\
    https://$ENDPOINT/api/v1/namespaces/$NAMESPACE/serviceaccounts/$NAME <<'EOF'
{
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.Patch
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the ServiceAccount
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.ServiceAccount
|401 Unauthorized|
|===

==== Consumes

* application/json-patch+json
* application/merge-patch+json
* application/strategic-merge-patch+json

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Delete-api-v1-namespaces-namespace-serviceaccounts-name]]
=== Delete a ServiceAccount in a namespace
Delete a ServiceAccount

==== HTTP request
----
DELETE /api/v1/namespaces/$NAMESPACE/serviceaccounts/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X DELETE \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/api/v1/namespaces/$NAMESPACE/serviceaccounts/$NAME <<'EOF'
{
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.DeleteOptions
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the ServiceAccount
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|gracePeriodSeconds|The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
|orphanDependents|Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the ""orphan"" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
|propagationPolicy|Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.Status
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Delete-api-v1-namespaces-namespace-serviceaccounts]]
=== Delete all ServiceAccounts in a namespace
Delete collection of ServiceAccount

==== HTTP request
----
DELETE /api/v1/namespaces/$NAMESPACE/serviceaccounts HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -X DELETE \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/api/v1/namespaces/$NAMESPACE/serviceaccounts
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.Status
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf



",12527,False,2382.882294326221,median
"/*
 * Copyright 2011 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include ""src/pdf/SkPDFDevice.h""

#include ""include/core/SkCanvas.h""
#include ""include/core/SkColor.h""
#include ""include/core/SkColorFilter.h""
#include ""include/core/SkPath.h""
#include ""include/core/SkPathEffect.h""
#include ""include/core/SkRRect.h""
#include ""include/core/SkString.h""
#include ""include/core/SkSurface.h""
#include ""include/core/SkTextBlob.h""
#include ""include/docs/SkPDFDocument.h""
#include ""include/encode/SkJpegEncoder.h""
#include ""include/pathops/SkPathOps.h""
#include ""include/private/SkTemplates.h""
#include ""include/private/SkTo.h""
#include ""src/core/SkAdvancedTypefaceMetrics.h""
#include ""src/core/SkAnnotationKeys.h""
#include ""src/core/SkBitmapDevice.h""
#include ""src/core/SkColorSpacePriv.h""
#include ""src/core/SkDraw.h""
#include ""src/core/SkGlyphRun.h""
#include ""src/core/SkImageFilterCache.h""
#include ""src/core/SkImageFilter_Base.h""
#include ""src/core/SkMaskFilterBase.h""
#include ""src/core/SkRasterClip.h""
#include ""src/core/SkScalerCache.h""
#include ""src/core/SkScopeExit.h""
#include ""src/core/SkStrikeSpec.h""
#include ""src/core/SkTextFormatParams.h""
#include ""src/core/SkXfermodeInterpretation.h""
#include ""src/pdf/SkBitmapKey.h""
#include ""src/pdf/SkClusterator.h""
#include ""src/pdf/SkPDFBitmap.h""
#include ""src/pdf/SkPDFDocumentPriv.h""
#include ""src/pdf/SkPDFFont.h""
#include ""src/pdf/SkPDFFormXObject.h""
#include ""src/pdf/SkPDFGraphicState.h""
#include ""src/pdf/SkPDFResourceDict.h""
#include ""src/pdf/SkPDFShader.h""
#include ""src/pdf/SkPDFTypes.h""
#include ""src/pdf/SkPDFUtils.h""
#include ""src/utils/SkClipStackUtils.h""
#include ""src/utils/SkUTF.h""

#include <vector>

#ifndef SK_PDF_MASK_QUALITY
    // If MASK_QUALITY is in [0,100], will be used for JpegEncoder.
    // Otherwise, just encode masks losslessly.
    #define SK_PDF_MASK_QUALITY 50
    // Since these masks are used for blurry shadows, we shouldn't need
    // high quality.  Raise this value if your shadows have visible JPEG
    // artifacts.
    // If SkJpegEncoder::Encode fails, we will fall back to the lossless
    // encoding.
#endif

namespace {

// If nodeId is not zero, outputs the tags to begin a marked-content sequence
// for the given node ID, and then closes those tags when this object goes
// out of scope.
class ScopedOutputMarkedContentTags {
public:
    ScopedOutputMarkedContentTags(int nodeId, SkPDFDocument* document, SkDynamicMemoryWStream* out)
        : fOut(out)
        , fMarkId(-1) {
        if (nodeId) {
            fMarkId = document->createMarkIdForNodeId(nodeId);
        }

        if (fMarkId != -1) {
            fOut->writeText(""/P <</MCID "");
            fOut->writeDecAsText(fMarkId);
            fOut->writeText("" >>BDC\\n"");
        }
    }

    ~ScopedOutputMarkedContentTags() {
        if (fMarkId != -1) {
            fOut->writeText(""EMC\\n"");
        }
    }

private:
    SkDynamicMemoryWStream* fOut;
    int fMarkId;
};

}  // namespace

// Utility functions

// This function destroys the mask and either frees or takes the pixels.
sk_sp<SkImage> mask_to_greyscale_image(SkMask* mask) {
    sk_sp<SkImage> img;
    SkPixmap pm(SkImageInfo::Make(mask->fBounds.width(), mask->fBounds.height(),
                                  kGray_8_SkColorType, kOpaque_SkAlphaType),
                mask->fImage, mask->fRowBytes);
    const int imgQuality = SK_PDF_MASK_QUALITY;
    if (imgQuality <= 100 && imgQuality >= 0) {
        SkDynamicMemoryWStream buffer;
        SkJpegEncoder::Options jpegOptions;
        jpegOptions.fQuality = imgQuality;
        if (SkJpegEncoder::Encode(&buffer, pm, jpegOptions)) {
            img = SkImage::MakeFromEncoded(buffer.detachAsData());
            SkASSERT(img);
            if (img) {
                SkMask::FreeImage(mask->fImage);
            }
        }
    }
    if (!img) {
        img = SkImage::MakeFromRaster(pm, [](const void* p, void*) { SkMask::FreeImage((void*)p); },
                                      nullptr);
    }
    *mask = SkMask();  // destructive;
    return img;
}

sk_sp<SkImage> alpha_image_to_greyscale_image(const SkImage* mask) {
    int w = mask->width(), h = mask->height();
    SkBitmap greyBitmap;
    greyBitmap.allocPixels(SkImageInfo::Make(w, h, kGray_8_SkColorType, kOpaque_SkAlphaType));
    // TODO: support gpu images in pdf
    if (!mask->readPixels(nullptr, SkImageInfo::MakeA8(w, h),
                          greyBitmap.getPixels(), greyBitmap.rowBytes(), 0, 0)) {
        return nullptr;
    }
    greyBitmap.setImmutable();
    return greyBitmap.asImage();
}

static int add_resource(SkTHashSet<SkPDFIndirectReference>& resources, SkPDFIndirectReference ref) {
    resources.add(ref);
    return ref.fValue;
}

static void draw_points(SkCanvas::PointMode mode,
                        size_t count,
                        const SkPoint* points,
                        const SkPaint& paint,
                        const SkIRect& bounds,
                        SkBaseDevice* device) {
    SkRasterClip rc(bounds);
    SkDraw draw;
    draw.fDst = SkPixmap(SkImageInfo::MakeUnknown(bounds.right(), bounds.bottom()), nullptr, 0);
    draw.fMatrixProvider = device;
    draw.fRC = &rc;
    draw.drawPoints(mode, count, points, paint, device);
}

// A shader's matrix is:  CTMM x LocalMatrix x WrappingLocalMatrix.  We want to
// switch to device space, where CTM = I, while keeping the original behavior.
//
//               I * LocalMatrix * NewWrappingMatrix = CTM * LocalMatrix
//                   LocalMatrix * NewWrappingMatrix = CTM * LocalMatrix
//  InvLocalMatrix * LocalMatrix * NewWrappingMatrix = InvLocalMatrix * CTM * LocalMatrix
//                                 NewWrappingMatrix = InvLocalMatrix * CTM * LocalMatrix
//
static void transform_shader(SkPaint* paint, const SkMatrix& ctm) {
    SkASSERT(!ctm.isIdentity());
    SkMatrix lm = SkPDFUtils::GetShaderLocalMatrix(paint->getShader());
    SkMatrix lmInv;
    if (lm.invert(&lmInv)) {
        SkMatrix m = SkMatrix::Concat(SkMatrix::Concat(lmInv, ctm), lm);
        paint->setShader(paint->getShader()->makeWithLocalMatrix(m));
    }
}

static SkTCopyOnFirstWrite<SkPaint> clean_paint(const SkPaint& srcPaint) {
    SkTCopyOnFirstWrite<SkPaint> paint(srcPaint);
    // If the paint will definitely draw opaquely, replace kSrc with
    // kSrcOver.  http://crbug.com/473572
    if (!paint->isSrcOver() &&
        kSrcOver_SkXfermodeInterpretation == SkInterpretXfermode(*paint, false))
    {
        paint.writable()->setBlendMode(SkBlendMode::kSrcOver);
    }
    if (paint->getColorFilter()) {
        // We assume here that PDFs all draw in sRGB.
        SkPaintPriv::RemoveColorFilter(paint.writable(), sk_srgb_singleton());
    }
    SkASSERT(!paint->getColorFilter());
    return paint;
}

static void set_style(SkTCopyOnFirstWrite<SkPaint>* paint, SkPaint::Style style) {
    if (paint->get()->getStyle() != style) {
        paint->writable()->setStyle(style);
    }
}

/* Calculate an inverted path's equivalent non-inverted path, given the
 * canvas bounds.
 * outPath may alias with invPath (since this is supported by PathOps).
 */
static bool calculate_inverse_path(const SkRect& bounds, const SkPath& invPath,
                                   SkPath* outPath) {
    SkASSERT(invPath.isInverseFillType());
    return Op(SkPath::Rect(bounds), invPath, kIntersect_SkPathOp, outPath);
}

SkBaseDevice* SkPDFDevice::onCreateDevice(const CreateInfo& cinfo, const SkPaint* layerPaint) {
    // PDF does not support image filters, so render them on CPU.
    // Note that this rendering is done at ""screen"" resolution (100dpi), not
    // printer resolution.

    // TODO: It may be possible to express some filters natively using PDF
    // to improve quality and file size (https://bug.skia.org/3043)
    if (layerPaint && (layerPaint->getImageFilter() || layerPaint->getColorFilter())) {
        // need to return a raster device, which we will detect in drawDevice()
        return SkBitmapDevice::Create(cinfo.fInfo, SkSurfaceProps(0, kUnknown_SkPixelGeometry));
    }
    return new SkPDFDevice(cinfo.fInfo.dimensions(), fDocument);
}

// A helper class to automatically finish a ContentEntry at the end of a
// drawing method and maintain the state needed between set up and finish.
class ScopedContentEntry {
public:
    ScopedContentEntry(SkPDFDevice* device,
                       const SkClipStack* clipStack,
                       const SkMatrix& matrix,
                       const SkPaint& paint,
                       SkScalar textScale = 0)
        : fDevice(device)
        , fBlendMode(SkBlendMode::kSrcOver)
        , fClipStack(clipStack)
    {
        if (matrix.hasPerspective()) {
            NOT_IMPLEMENTED(!matrix.hasPerspective(), false);
            return;
        }
        fBlendMode = paint.getBlendMode_or(SkBlendMode::kSrcOver);
        fContentStream =
            fDevice->setUpContentEntry(clipStack, matrix, paint, textScale, &fDstFormXObject);
    }
    ScopedContentEntry(SkPDFDevice* dev, const SkPaint& paint, SkScalar textScale = 0)
        : ScopedContentEntry(dev, &dev->cs(), dev->localToDevice(), paint, textScale) {}

    ~ScopedContentEntry() {
        if (fContentStream) {
            SkPath* shape = &fShape;
            if (shape->isEmpty()) {
                shape = nullptr;
            }
            fDevice->finishContentEntry(fClipStack, fBlendMode, fDstFormXObject, shape);
        }
    }

    explicit operator bool() const { return fContentStream != nullptr; }
    SkDynamicMemoryWStream* stream() { return fContentStream; }

    /* Returns true when we explicitly need the shape of the drawing. */
    bool needShape() {
        switch (fBlendMode) {
            case SkBlendMode::kClear:
            case SkBlendMode::kSrc:
            case SkBlendMode::kSrcIn:
            case SkBlendMode::kSrcOut:
            case SkBlendMode::kDstIn:
            case SkBlendMode::kDstOut:
            case SkBlendMode::kSrcATop:
            case SkBlendMode::kDstATop:
            case SkBlendMode::kModulate:
                return true;
            default:
                return false;
        }
    }

    /* Returns true unless we only need the shape of the drawing. */
    bool needSource() {
        if (fBlendMode == SkBlendMode::kClear) {
            return false;
        }
        return true;
    }

    /* If the shape is different than the alpha component of the content, then
     * setShape should be called with the shape.  In particular, images and
     * devices have rectangular shape.
     */
    void setShape(const SkPath& shape) {
        fShape = shape;
    }

private:
    SkPDFDevice* fDevice = nullptr;
    SkDynamicMemoryWStream* fContentStream = nullptr;
    SkBlendMode fBlendMode;
    SkPDFIndirectReference fDstFormXObject;
    SkPath fShape;
    const SkClipStack* fClipStack;
};

////////////////////////////////////////////////////////////////////////////////

SkPDFDevice::SkPDFDevice(SkISize pageSize, SkPDFDocument* doc, const SkMatrix& transform)
    : INHERITED(SkImageInfo::MakeUnknown(pageSize.width(), pageSize.height()),
                SkSurfaceProps(0, kUnknown_SkPixelGeometry))
    , fInitialTransform(transform)
    , fNodeId(0)
    , fDocument(doc)
{
    SkASSERT(!pageSize.isEmpty());
}

SkPDFDevice::~SkPDFDevice() = default;

void SkPDFDevice::reset() {
    fGraphicStateResources.reset();
    fXObjectResources.reset();
    fShaderResources.reset();
    fFontResources.reset();
    fContent.reset();
    fActiveStackState = SkPDFGraphicStackState();
}

void SkPDFDevice::drawAnnotation(const SkRect& rect, const char key[], SkData* value) {
    if (!value) {
        return;
    }
    // Annotations are specified in absolute coordinates, so the page xform maps from device space
    // to the global space, and applies the document transform.
    SkMatrix pageXform = this->deviceToGlobal().asM33();
    pageXform.postConcat(fDocument->currentPageTransform());
    if (rect.isEmpty()) {
        if (!strcmp(key, SkPDFGetNodeIdKey())) {
            int nodeID;
            if (value->size() != sizeof(nodeID)) { return; }
            memcpy(&nodeID, value->data(), sizeof(nodeID));
            fNodeId = nodeID;
            return;
        }
        if (!strcmp(SkAnnotationKeys::Define_Named_Dest_Key(), key)) {
            SkPoint p = this->localToDevice().mapXY(rect.x(), rect.y());
            pageXform.mapPoints(&p, 1);
            auto pg = fDocument->currentPage();
            fDocument->fNamedDestinations.push_back(SkPDFNamedDestination{sk_ref_sp(value), p, pg});
        }
        return;
    }
    // Convert to path to handle non-90-degree rotations.
    SkPath path = SkPath::Rect(rect).makeTransform(this->localToDevice());
    SkPath clip;
    SkClipStack_AsPath(this->cs(), &clip);
    Op(clip, path, kIntersect_SkPathOp, &path);
    // PDF wants a rectangle only.
    SkRect transformedRect = pageXform.mapRect(path.getBounds());
    if (transformedRect.isEmpty()) {
        return;
    }

    SkPDFLink::Type linkType = SkPDFLink::Type::kNone;
    if (!strcmp(SkAnnotationKeys::URL_Key(), key)) {
        linkType = SkPDFLink::Type::kUrl;
    } else if (!strcmp(SkAnnotationKeys::Link_Named_Dest_Key(), key)) {
        linkType = SkPDFLink::Type::kNamedDestination;
    }

    if (linkType != SkPDFLink::Type::kNone) {
        std::unique_ptr<SkPDFLink> link = std::make_unique<SkPDFLink>(
            linkType, value, transformedRect, fNodeId);
        fDocument->fCurrentPageLinks.push_back(std::move(link));
    }
}

void SkPDFDevice::drawPaint(const SkPaint& srcPaint) {
    SkMatrix inverse;
    if (!this->localToDevice().invert(&inverse)) {
        return;
    }
    SkRect bbox = this->cs().bounds(this->bounds());
    inverse.mapRect(&bbox);
    bbox.roundOut(&bbox);
    if (this->hasEmptyClip()) {
        return;
    }
    SkPaint newPaint = srcPaint;
    newPaint.setStyle(SkPaint::kFill_Style);
    this->drawRect(bbox, newPaint);
}

void SkPDFDevice::drawPoints(SkCanvas::PointMode mode,
                             size_t count,
                             const SkPoint* points,
                             const SkPaint& srcPaint) {
    if (this->hasEmptyClip()) {
        return;
    }
    if (count == 0) {
        return;
    }
    SkTCopyOnFirstWrite<SkPaint> paint(clean_paint(srcPaint));



    if (SkCanvas::kPoints_PointMode != mode) {
        set_style(&paint, SkPaint::kStroke_Style);
    }

    // SkDraw::drawPoints converts to multiple calls to fDevice->drawPath.
    // We only use this when there's a path effect because of the overhead
    // of multiple calls to setUpContentEntry it causes.
    if (paint->getPathEffect()) {
        draw_points(mode, count, points, *paint, this->devClipBounds(), this);
        return;
    }


    if (mode == SkCanvas::kPoints_PointMode && paint->getStrokeCap() != SkPaint::kRound_Cap) {
        if (paint->getStrokeWidth()) {
            // PDF won't draw a single point with square/butt caps because the
            // orientation is ambiguous.  Draw a rectangle instead.
            set_style(&paint, SkPaint::kFill_Style);
            SkScalar strokeWidth = paint->getStrokeWidth();
            SkScalar halfStroke = SkScalarHalf(strokeWidth);
            for (size_t i = 0; i < count; i++) {
                SkRect r = SkRect::MakeXYWH(points[i].fX, points[i].fY, 0, 0);
                r.inset(-halfStroke, -halfStroke);
                this->drawRect(r, *paint);
            }
            return;
        } else {
            if (paint->getStrokeCap() != SkPaint::kRound_Cap) {
                paint.writable()->setStrokeCap(SkPaint::kRound_Cap);
            }
        }
    }

    ScopedContentEntry content(this, *paint);
    if (!content) {
        return;
    }
    SkDynamicMemoryWStream* contentStream = content.stream();
    switch (mode) {
        case SkCanvas::kPolygon_PointMode:
            SkPDFUtils::MoveTo(points[0].fX, points[0].fY, contentStream);
            for (size_t i = 1; i < count; i++) {
                SkPDFUtils::AppendLine(points[i].fX, points[i].fY, contentStream);
            }
            SkPDFUtils::StrokePath(contentStream);
            break;
        case SkCanvas::kLines_PointMode:
            for (size_t i = 0; i < count/2; i++) {
                SkPDFUtils::MoveTo(points[i * 2].fX, points[i * 2].fY, contentStream);
                SkPDFUtils::AppendLine(points[i * 2 + 1].fX, points[i * 2 + 1].fY, contentStream);
                SkPDFUtils::StrokePath(contentStream);
            }
            break;
        case SkCanvas::kPoints_PointMode:
            SkASSERT(paint->getStrokeCap() == SkPaint::kRound_Cap);
            for (size_t i = 0; i < count; i++) {
                SkPDFUtils::MoveTo(points[i].fX, points[i].fY, contentStream);
                SkPDFUtils::ClosePath(contentStream);
                SkPDFUtils::StrokePath(contentStream);
            }
            break;
        default:
            SkASSERT(false);
    }
}

void SkPDFDevice::drawRect(const SkRect& rect, const SkPaint& paint) {
    SkRect r = rect;
    r.sort();
    this->internalDrawPath(this->cs(), this->localToDevice(), SkPath::Rect(r), paint, true);
}

void SkPDFDevice::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
    this->internalDrawPath(this->cs(), this->localToDevice(), SkPath::RRect(rrect), paint, true);
}

void SkPDFDevice::drawOval(const SkRect& oval, const SkPaint& paint) {
    this->internalDrawPath(this->cs(), this->localToDevice(), SkPath::Oval(oval), paint, true);
}

void SkPDFDevice::drawPath(const SkPath& path, const SkPaint& paint, bool pathIsMutable) {
    this->internalDrawPath(this->cs(), this->localToDevice(), path, paint, pathIsMutable);
}

void SkPDFDevice::internalDrawPathWithFilter(const SkClipStack& clipStack,
                                             const SkMatrix& ctm,
                                             const SkPath& origPath,
                                             const SkPaint& origPaint) {
    SkASSERT(origPaint.getMaskFilter());
    SkPath path(origPath);
    SkTCopyOnFirstWrite<SkPaint> paint(origPaint);

    SkStrokeRec::InitStyle initStyle = paint->getFillPath(path, &path)
                                     ? SkStrokeRec::kFill_InitStyle
                                     : SkStrokeRec::kHairline_InitStyle;
    path.transform(ctm, &path);

    SkIRect bounds = clipStack.bounds(this->bounds()).roundOut();
    SkMask sourceMask;
    if (!SkDraw::DrawToMask(path, &bounds, paint->getMaskFilter(), &SkMatrix::I(),
                            &sourceMask, SkMask::kComputeBoundsAndRenderImage_CreateMode,
                            initStyle)) {
        return;
    }
    SkAutoMaskFreeImage srcAutoMaskFreeImage(sourceMask.fImage);
    SkMask dstMask;
    SkIPoint margin;
    if (!as_MFB(paint->getMaskFilter())->filterMask(&dstMask, sourceMask, ctm, &margin)) {
        return;
    }
    SkIRect dstMaskBounds = dstMask.fBounds;
    sk_sp<SkImage> mask = mask_to_greyscale_image(&dstMask);
    // PDF doesn't seem to allow masking vector graphics with an Image XObject.
    // Must mask with a Form XObject.
    sk_sp<SkPDFDevice> maskDevice = this->makeCongruentDevice();
    {
        SkCanvas canvas(maskDevice);
        canvas.drawImage(mask, dstMaskBounds.x(), dstMaskBounds.y());
    }
    if (!ctm.isIdentity() && paint->getShader()) {
        transform_shader(paint.writable(), ctm); // Since we are using identity matrix.
    }
    ScopedContentEntry content(this, &clipStack, SkMatrix::I(), *paint);
    if (!content) {
        return;
    }
    this->setGraphicState(SkPDFGraphicState::GetSMaskGraphicState(
            maskDevice->makeFormXObjectFromDevice(dstMaskBounds, true), false,
            SkPDFGraphicState::kLuminosity_SMaskMode, fDocument), content.stream());
    SkPDFUtils::AppendRectangle(SkRect::Make(dstMaskBounds), content.stream());
    SkPDFUtils::PaintPath(SkPaint::kFill_Style, path.getFillType(), content.stream());
    this->clearMaskOnGraphicState(content.stream());
}

void SkPDFDevice::setGraphicState(SkPDFIndirectReference gs, SkDynamicMemoryWStream* content) {
    SkPDFUtils::ApplyGraphicState(add_resource(fGraphicStateResources, gs), content);
}

void SkPDFDevice::clearMaskOnGraphicState(SkDynamicMemoryWStream* contentStream) {
    // The no-softmask graphic state is used to ""turn off"" the mask for later draw calls.
    SkPDFIndirectReference& noSMaskGS = fDocument->fNoSmaskGraphicState;
    if (!noSMaskGS) {
        SkPDFDict tmp(""ExtGState"");
        tmp.insertName(""SMask"", ""None"");
        noSMaskGS = fDocument->emit(tmp);
    }
    this->setGraphicState(noSMaskGS, contentStream);
}

void SkPDFDevice::internalDrawPath(const SkClipStack& clipStack,
                                   const SkMatrix& ctm,
                                   const SkPath& origPath,
                                   const SkPaint& srcPaint,
                                   bool pathIsMutable) {
    if (clipStack.isEmpty(this->bounds())) {
        return;
    }
    SkTCopyOnFirstWrite<SkPaint> paint(clean_paint(srcPaint));
    SkPath modifiedPath;
    SkPath* pathPtr = const_cast<SkPath*>(&origPath);

    if (paint->getMaskFilter()) {
        this->internalDrawPathWithFilter(clipStack, ctm, origPath, *paint);
        return;
    }

    SkMatrix matrix = ctm;

    if (paint->getPathEffect()) {
        if (clipStack.isEmpty(this->bounds())) {
            return;
        }
        if (!pathIsMutable) {
            modifiedPath = origPath;
            pathPtr = &modifiedPath;
            pathIsMutable = true;
        }
        if (paint->getFillPath(*pathPtr, pathPtr)) {
            set_style(&paint, SkPaint::kFill_Style);
        } else {
            set_style(&paint, SkPaint::kStroke_Style);
            if (paint->getStrokeWidth() != 0) {
                paint.writable()->setStrokeWidth(0);
            }
        }
        paint.writable()->setPathEffect(nullptr);
    }

    if (this->handleInversePath(*pathPtr, *paint, pathIsMutable)) {
        return;
    }
    if (matrix.getType() & SkMatrix::kPerspective_Mask) {
        if (!pathIsMutable) {
            modifiedPath = origPath;
            pathPtr = &modifiedPath;
            pathIsMutable = true;
        }
        pathPtr->transform(matrix);
        if (paint->getShader()) {
            transform_shader(paint.writable(), matrix);
        }
        matrix = SkMatrix::I();
    }

    ScopedContentEntry content(this, &clipStack, matrix, *paint);
    if (!content) {
        return;
    }
    constexpr SkScalar kToleranceScale = 0.0625f;  // smaller = better conics (circles).
    SkScalar matrixScale = matrix.mapRadius(1.0f);
    SkScalar tolerance = matrixScale > 0.0f ? kToleranceScale / matrixScale : kToleranceScale;
    bool consumeDegeratePathSegments =
           paint->getStyle() == SkPaint::kFill_Style ||
           (paint->getStrokeCap() != SkPaint::kRound_Cap &&
            paint->getStrokeCap() != SkPaint::kSquare_Cap);
    SkPDFUtils::EmitPath(*pathPtr, paint->getStyle(), consumeDegeratePathSegments, content.stream(),
                         tolerance);
    SkPDFUtils::PaintPath(paint->getStyle(), pathPtr->getFillType(), content.stream());
}

////////////////////////////////////////////////////////////////////////////////

void SkPDFDevice::drawImageRect(const SkImage* image,
                                const SkRect* src,
                                const SkRect& dst,
                                const SkSamplingOptions& sampling,
                                const SkPaint& paint,
                                SkCanvas::SrcRectConstraint) {
    SkASSERT(image);
    this->internalDrawImageRect(SkKeyedImage(sk_ref_sp(const_cast<SkImage*>(image))),
                                src, dst, sampling, paint, this->localToDevice());
}

void SkPDFDevice::drawSprite(const SkBitmap& bm, int x, int y, const SkPaint& paint) {
    SkASSERT(!bm.drawsNothing());
    auto r = SkRect::MakeXYWH(x, y, bm.width(), bm.height());
    this->internalDrawImageRect(SkKeyedImage(bm), nullptr, r, SkSamplingOptions(), paint,
                                SkMatrix::I());
}

////////////////////////////////////////////////////////////////////////////////

namespace {
class GlyphPositioner {
public:
    GlyphPositioner(SkDynamicMemoryWStream* content,
                    SkScalar textSkewX,
                    SkPoint origin)
        : fContent(content)
        , fCurrentMatrixOrigin(origin)
        , fTextSkewX(textSkewX) {
    }
    ~GlyphPositioner() { this->flush(); }
    void flush() {
        if (fInText) {
            fContent->writeText(""> Tj\\n"");
            fInText = false;
        }
    }
    void setFont(SkPDFFont* pdfFont) {
        this->flush();
        fPDFFont = pdfFont;
        // Reader 2020.013.20064 incorrectly advances some Type3 fonts https://crbug.com/1226960
        bool convertedToType3 = fPDFFont->getType() == SkAdvancedTypefaceMetrics::kOther_Font;
        bool thousandEM = fPDFFont->typeface()->getUnitsPerEm() == 1000;
        fViewersAgreeOnAdvancesInFont = thousandEM || !convertedToType3;
    }
    void writeGlyph(uint16_t glyph, SkScalar advanceWidth, SkPoint xy) {
        SkASSERT(fPDFFont);
        if (!fInitialized) {
            // Flip the text about the x-axis to account for origin swap and include
            // the passed parameters.
            fContent->writeText(""1 0 "");
            SkPDFUtils::AppendScalar(-fTextSkewX, fContent);
            fContent->writeText("" -1 "");
            SkPDFUtils::AppendScalar(fCurrentMatrixOrigin.x(), fContent);
            fContent->writeText("" "");
            SkPDFUtils::AppendScalar(fCurrentMatrixOrigin.y(), fContent);
            fContent->writeText("" Tm\\n"");
            fCurrentMatrixOrigin.set(0.0f, 0.0f);
            fInitialized = true;
        }
        SkPoint position = xy - fCurrentMatrixOrigin;
        if (!fViewersAgreeOnXAdvance || position != SkPoint{fXAdvance, 0}) {
            this->flush();
            SkPDFUtils::AppendScalar(position.x() - position.y() * fTextSkewX, fContent);
            fContent->writeText("" "");
            SkPDFUtils::AppendScalar(-position.y(), fContent);
            fContent->writeText("" Td "");
            fCurrentMatrixOrigin = xy;
            fXAdvance = 0;
            fViewersAgreeOnXAdvance = true;
        }
        fXAdvance += advanceWidth;
        if (!fViewersAgreeOnAdvancesInFont) {
            fViewersAgreeOnXAdvance = false;
        }
        if (!fInText) {
            fContent->writeText(""<"");
            fInText = true;
        }
        if (fPDFFont->multiByteGlyphs()) {
            SkPDFUtils::WriteUInt16BE(fContent, glyph);
        } else {
            SkASSERT(0 == glyph >> 8);
            SkPDFUtils::WriteUInt8(fContent, static_cast<uint8_t>(glyph));
        }
    }

private:
    SkDynamicMemoryWStream* fContent;
    SkPDFFont* fPDFFont = nullptr;
    SkPoint fCurrentMatrixOrigin;
    SkScalar fXAdvance = 0.0f;
    bool fViewersAgreeOnAdvancesInFont = true;
    bool fViewersAgreeOnXAdvance = true;
    SkScalar fTextSkewX;
    bool fInText = false;
    bool fInitialized = false;
};
}  // namespace

static SkUnichar map_glyph(const std::vector<SkUnichar>& glyphToUnicode, SkGlyphID glyph) {
    return glyph < glyphToUnicode.size() ? glyphToUnicode[SkToInt(glyph)] : -1;
}

namespace {
struct PositionedGlyph {
    SkPoint fPos;
    SkGlyphID fGlyph;
};
}  // namespace

static SkRect get_glyph_bounds_device_space(const SkGlyph* glyph,
                                            SkScalar xScale, SkScalar yScale,
                                            SkPoint xy, const SkMatrix& ctm) {
    SkRect glyphBounds = SkMatrix::Scale(xScale, yScale).mapRect(glyph->rect());
    glyphBounds.offset(xy);
    ctm.mapRect(&glyphBounds); // now in dev space.
    return glyphBounds;
}

static bool contains(const SkRect& r, SkPoint p) {
   return r.left() <= p.x() && p.x() <= r.right() &&
          r.top()  <= p.y() && p.y() <= r.bottom();
}

void SkPDFDevice::drawGlyphRunAsPath(
        const SkGlyphRun& glyphRun, SkPoint offset, const SkPaint& runPaint) {
    const SkFont& font = glyphRun.font();
    SkPath path;

    struct Rec {
        SkPath* fPath;
        SkPoint fOffset;
        const SkPoint* fPos;
    } rec = {&path, offset, glyphRun.positions().data()};

    font.getPaths(glyphRun.glyphsIDs().data(), glyphRun.glyphsIDs().size(),
                  [](const SkPath* path, const SkMatrix& mx, void* ctx) {
                      Rec* rec = reinterpret_cast<Rec*>(ctx);
                      if (path) {
                          SkMatrix total = mx;
                          total.postTranslate(rec->fPos->fX + rec->fOffset.fX,
                                              rec->fPos->fY + rec->fOffset.fY);
                          rec->fPath->addPath(*path, total);
                      }
                      rec->fPos += 1; // move to the next glyph's position
                  }, &rec);
    this->internalDrawPath(this->cs(), this->localToDevice(), path, runPaint, true);

    SkFont transparentFont = glyphRun.font();
    transparentFont.setEmbolden(false); // Stop Recursion
    SkGlyphRun tmpGlyphRun(glyphRun, transparentFont);

    SkPaint transparent;
    transparent.setColor(SK_ColorTRANSPARENT);

    if (this->localToDevice().hasPerspective()) {
        SkAutoDeviceTransformRestore adr(this, SkMatrix::I());
        this->internalDrawGlyphRun(tmpGlyphRun, offset, transparent);
    } else {
        this->internalDrawGlyphRun(tmpGlyphRun, offset, transparent);
    }
}

static bool needs_new_font(SkPDFFont* font, const SkGlyph* glyph,
                           SkAdvancedTypefaceMetrics::FontType fontType) {
    if (!font || !font->hasGlyph(glyph->getGlyphID())) {
        return true;
    }
    if (fontType == SkAdvancedTypefaceMetrics::kOther_Font) {
        return false;
    }
    if (glyph->isEmpty()) {
        return false;
    }

    bool bitmapOnly = nullptr == glyph->path();
    bool convertedToType3 = (font->getType() == SkAdvancedTypefaceMetrics::kOther_Font);
    return convertedToType3 != bitmapOnly;
}

void SkPDFDevice::internalDrawGlyphRun(
        const SkGlyphRun& glyphRun, SkPoint offset, const SkPaint& runPaint) {

    const SkGlyphID* glyphIDs = glyphRun.glyphsIDs().data();
    uint32_t glyphCount = SkToU32(glyphRun.glyphsIDs().size());
    const SkFont& glyphRunFont = glyphRun.font();

    if (!glyphCount || !glyphIDs || glyphRunFont.getSize() <= 0 || this->hasEmptyClip()) {
        return;
    }
    if (runPaint.getPathEffect()
        || runPaint.getMaskFilter()
        || glyphRunFont.isEmbolden()
        || this->localToDevice().hasPerspective()
        || SkPaint::kFill_Style != runPaint.getStyle()) {
        // Stroked Text doesn't work well with Type3 fonts.
        this->drawGlyphRunAsPath(glyphRun, offset, runPaint);
        return;
    }
    SkTypeface* typeface = glyphRunFont.getTypefaceOrDefault();
    if (!typeface) {
        SkDebugf(""SkPDF: SkTypeface::MakeDefault() returned nullptr.\\n"");
        return;
    }

    const SkAdvancedTypefaceMetrics* metrics = SkPDFFont::GetMetrics(typeface, fDocument);
    if (!metrics) {
        return;
    }
    SkAdvancedTypefaceMetrics::FontType fontType = SkPDFFont::FontType(*metrics);

    const std::vector<SkUnichar>& glyphToUnicode = SkPDFFont::GetUnicodeMap(typeface, fDocument);

    SkClusterator clusterator(glyphRun);

    int emSize;
    SkStrikeSpec strikeSpec = SkStrikeSpec::MakePDFVector(*typeface, &emSize);

    SkScalar textSize = glyphRunFont.getSize();
    SkScalar advanceScale = textSize * glyphRunFont.getScaleX() / emSize;

    // textScaleX and textScaleY are used to get a conservative bounding box for glyphs.
    SkScalar textScaleY = textSize / emSize;
    SkScalar textScaleX = advanceScale + glyphRunFont.getSkewX() * textScaleY;

    SkRect clipStackBounds = this->cs().bounds(this->bounds());

    SkTCopyOnFirstWrite<SkPaint> paint(clean_paint(runPaint));
    ScopedContentEntry content(this, *paint, glyphRunFont.getScaleX());
    if (!content) {
        return;
    }
    SkDynamicMemoryWStream* out = content.stream();

    out->writeText(""BT\\n"");
    SK_AT_SCOPE_EXIT(out->writeText(""ET\\n""));

    ScopedOutputMarkedContentTags mark(fNodeId, fDocument, out);

    const int numGlyphs = typeface->countGlyphs();

    if (clusterator.reversedChars()) {
        out->writeText(""/ReversedChars BMC\\n"");
    }
    SK_AT_SCOPE_EXIT(if (clusterator.reversedChars()) { out->writeText(""EMC\\n""); } );
    GlyphPositioner glyphPositioner(out, glyphRunFont.getSkewX(), offset);
    SkPDFFont* font = nullptr;

    SkBulkGlyphMetricsAndPaths paths{strikeSpec};
    auto glyphs = paths.glyphs(glyphRun.glyphsIDs());

    while (SkClusterator::Cluster c = clusterator.next()) {
        int index = c.fGlyphIndex;
        int glyphLimit = index + c.fGlyphCount;

        bool actualText = false;
        SK_AT_SCOPE_EXIT(if (actualText) {
                             glyphPositioner.flush();
                             out->writeText(""EMC\\n"");
                         });
        if (c.fUtf8Text) {  // real cluster
            // Check if `/ActualText` needed.
            const char* textPtr = c.fUtf8Text;
            const char* textEnd = c.fUtf8Text + c.fTextByteLength;
            SkUnichar unichar = SkUTF::NextUTF8(&textPtr, textEnd);
            if (unichar < 0) {
                return;
            }
            if (textPtr < textEnd ||                                  // more characters left
                glyphLimit > index + 1 ||                             // toUnicode wouldn't work
                unichar != map_glyph(glyphToUnicode, glyphIDs[index]))  // test single Unichar map
            {
                glyphPositioner.flush();
                out->writeText(""/Span<</ActualText <"");
                SkPDFUtils::WriteUTF16beHex(out, 0xFEFF);  // U+FEFF = BYTE ORDER MARK
                // the BOM marks this text as UTF-16BE, not PDFDocEncoding.
                SkPDFUtils::WriteUTF16beHex(out, unichar);  // first char
                while (textPtr < textEnd) {
                    unichar = SkUTF::NextUTF8(&textPtr, textEnd);
                    if (unichar < 0) {
                        break;
                    }
                    SkPDFUtils::WriteUTF16beHex(out, unichar);
                }
                out->writeText(""> >> BDC\\n"");  // begin marked-content sequence
                                               // with an associated property list.
                actualText = true;
            }
        }
        for (; index < glyphLimit; ++index) {
            SkGlyphID gid = glyphIDs[index];
            if (numGlyphs <= gid) {
                continue;
            }
            SkPoint xy = glyphRun.positions()[index];
            // Do a glyph-by-glyph bounds-reject if positions are absolute.
            SkRect glyphBounds = get_glyph_bounds_device_space(
                    glyphs[index], textScaleX, textScaleY,
                    xy + offset, this->localToDevice());
            if (glyphBounds.isEmpty()) {
                if (!contains(clipStackBounds, {glyphBounds.x(), glyphBounds.y()})) {
                    continue;
                }
            } else {
                if (!clipStackBounds.intersects(glyphBounds)) {
                    continue;  // reject glyphs as out of bounds
                }
            }
            if (needs_new_font(font, glyphs[index], fontType)) {
                // Not yet specified font or need to switch font.
                font = SkPDFFont::GetFontResource(fDocument, glyphs[index], typeface);
                SkASSERT(font);  // All preconditions for SkPDFFont::GetFontResource are met.
                glyphPositioner.setFont(font);
                SkPDFWriteResourceName(out, SkPDFResourceType::kFont,
                                       add_resource(fFontResources, font->indirectReference()));
                out->writeText("" "");
                SkPDFUtils::AppendScalar(textSize, out);
                out->writeText("" Tf\\n"");

            }
            font->noteGlyphUsage(gid);
            SkGlyphID encodedGlyph = font->glyphToPDFFontEncoding(gid);
            SkScalar advance = advanceScale * glyphs[index]->advanceX();
            glyphPositioner.writeGlyph(encodedGlyph, advance, xy);
        }
    }
}

void SkPDFDevice::onDrawGlyphRunList(const SkGlyphRunList& glyphRunList, const SkPaint& paint) {
    SkASSERT(!glyphRunList.hasRSXForm());
    for (const SkGlyphRun& glyphRun : glyphRunList) {
        this->internalDrawGlyphRun(glyphRun, glyphRunList.origin(), paint);
    }
}

void SkPDFDevice::drawVertices(const SkVertices*, SkBlendMode, const SkPaint&) {
    if (this->hasEmptyClip()) {
        return;
    }
    // TODO: implement drawVertices
}

void SkPDFDevice::drawFormXObject(SkPDFIndirectReference xObject, SkDynamicMemoryWStream* content) {
    ScopedOutputMarkedContentTags mark(fNodeId, fDocument, content);

    SkASSERT(xObject);
    SkPDFWriteResourceName(content, SkPDFResourceType::kXObject,
                           add_resource(fXObjectResources, xObject));
    content->writeText("" Do\\n"");
}

sk_sp<SkSurface> SkPDFDevice::makeSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
    return SkSurface::MakeRaster(info, &props);
}

static std::vector<SkPDFIndirectReference> sort(const SkTHashSet<SkPDFIndirectReference>& src) {
    std::vector<SkPDFIndirectReference> dst;
    dst.reserve(src.count());
    for (SkPDFIndirectReference ref : src) {
        dst.push_back(ref);
    }
    std::sort(dst.begin(), dst.end(),
            [](SkPDFIndirectReference a, SkPDFIndirectReference b) { return a.fValue < b.fValue; });
    return dst;
}

std::unique_ptr<SkPDFDict> SkPDFDevice::makeResourceDict() {
    return SkPDFMakeResourceDict(sort(fGraphicStateResources),
                                 sort(fShaderResources),
                                 sort(fXObjectResources),
                                 sort(fFontResources));
}

std::unique_ptr<SkStreamAsset> SkPDFDevice::content() {
    if (fActiveStackState.fContentStream) {
        fActiveStackState.drainStack();
        fActiveStackState = SkPDFGraphicStackState();
    }
    if (fContent.bytesWritten() == 0) {
        return std::make_unique<SkMemoryStream>();
    }
    SkDynamicMemoryWStream buffer;
    if (fInitialTransform.getType() != SkMatrix::kIdentity_Mask) {
        SkPDFUtils::AppendTransform(fInitialTransform, &buffer);
    }
    if (fNeedsExtraSave) {
        buffer.writeText(""q\\n"");
    }
    fContent.writeToAndReset(&buffer);
    if (fNeedsExtraSave) {
        buffer.writeText(""Q\\n"");
    }
    fNeedsExtraSave = false;
    return std::unique_ptr<SkStreamAsset>(buffer.detachAsStream());
}

/* Draws an inverse filled path by using Path Ops to compute the positive
 * inverse using the current clip as the inverse bounds.
 * Return true if this was an inverse path and was properly handled,
 * otherwise returns false and the normal drawing routine should continue,
 * either as a (incorrect) fallback or because the path was not inverse
 * in the first place.
 */
bool SkPDFDevice::handleInversePath(const SkPath& origPath,
                                    const SkPaint& paint,
                                    bool pathIsMutable) {
    if (!origPath.isInverseFillType()) {
        return false;
    }

    if (this->hasEmptyClip()) {
        return false;
    }

    SkPath modifiedPath;
    SkPath* pathPtr = const_cast<SkPath*>(&origPath);
    SkPaint noInversePaint(paint);

    // Merge stroking operations into final path.
    if (SkPaint::kStroke_Style == paint.getStyle() ||
        SkPaint::kStrokeAndFill_Style == paint.getStyle()) {
        bool doFillPath = paint.getFillPath(origPath, &modifiedPath);
        if (doFillPath) {
            noInversePaint.setStyle(SkPaint::kFill_Style);
            noInversePaint.setStrokeWidth(0);
            pathPtr = &modifiedPath;
        } else {
            // To be consistent with the raster output, hairline strokes
            // are rendered as non-inverted.
            modifiedPath.toggleInverseFillType();
            this->internalDrawPath(this->cs(), this->localToDevice(), modifiedPath, paint, true);
            return true;
        }
    }

    // Get bounds of clip in current transform space
    // (clip bounds are given in device space).
    SkMatrix transformInverse;
    SkMatrix totalMatrix = this->localToDevice();

    if (!totalMatrix.invert(&transformInverse)) {
        return false;
    }
    SkRect bounds = this->cs().bounds(this->bounds());
    transformInverse.mapRect(&bounds);

    // Extend the bounds by the line width (plus some padding)
    // so the edge doesn't cause a visible stroke.
    bounds.outset(paint.getStrokeWidth() + SK_Scalar1,
                  paint.getStrokeWidth() + SK_Scalar1);

    if (!calculate_inverse_path(bounds, *pathPtr, &modifiedPath)) {
        return false;
    }

    this->internalDrawPath(this->cs(), this->localToDevice(), modifiedPath, noInversePaint, true);
    return true;
}

SkPDFIndirectReference SkPDFDevice::makeFormXObjectFromDevice(SkIRect bounds, bool alpha) {
    SkMatrix inverseTransform = SkMatrix::I();
    if (!fInitialTransform.isIdentity()) {
        if (!fInitialTransform.invert(&inverseTransform)) {
            SkDEBUGFAIL(""Layer initial transform should be invertible."");
            inverseTransform.reset();
        }
    }
    const char* colorSpace = alpha ? ""DeviceGray"" : nullptr;

    SkPDFIndirectReference xobject =
        SkPDFMakeFormXObject(fDocument, this->content(),
                             SkPDFMakeArray(bounds.left(), bounds.top(),
                                            bounds.right(), bounds.bottom()),
                             this->makeResourceDict(), inverseTransform, colorSpace);
    // We always draw the form xobjects that we create back into the device, so
    // we simply preserve the font usage instead of pulling it out and merging
    // it back in later.
    this->reset();
    return xobject;
}

SkPDFIndirectReference SkPDFDevice::makeFormXObjectFromDevice(bool alpha) {
    return this->makeFormXObjectFromDevice(SkIRect{0, 0, this->width(), this->height()}, alpha);
}

void SkPDFDevice::drawFormXObjectWithMask(SkPDFIndirectReference xObject,
                                          SkPDFIndirectReference sMask,
                                          SkBlendMode mode,
                                          bool invertClip) {
    SkASSERT(sMask);
    SkPaint paint;
    paint.setBlendMode(mode);
    ScopedContentEntry content(this, nullptr, SkMatrix::I(), paint);
    if (!content) {
        return;
    }
    this->setGraphicState(SkPDFGraphicState::GetSMaskGraphicState(
            sMask, invertClip, SkPDFGraphicState::kAlpha_SMaskMode,
            fDocument), content.stream());
    this->drawFormXObject(xObject, content.stream());
    this->clearMaskOnGraphicState(content.stream());
}


static bool treat_as_regular_pdf_blend_mode(SkBlendMode blendMode) {
    return nullptr != SkPDFUtils::BlendModeName(blendMode);
}

static void populate_graphic_state_entry_from_paint(
        SkPDFDocument* doc,
        const SkMatrix& matrix,
        const SkClipStack* clipStack,
        SkIRect deviceBounds,
        const SkPaint& paint,
        const SkMatrix& initialTransform,
        SkScalar textScale,
        SkPDFGraphicStackState::Entry* entry,
        SkTHashSet<SkPDFIndirectReference>* shaderResources,
        SkTHashSet<SkPDFIndirectReference>* graphicStateResources) {
    NOT_IMPLEMENTED(paint.getPathEffect() != nullptr, false);
    NOT_IMPLEMENTED(paint.getMaskFilter() != nullptr, false);
    NOT_IMPLEMENTED(paint.getColorFilter() != nullptr, false);

    entry->fMatrix = matrix;
    entry->fClipStackGenID = clipStack ? clipStack->getTopmostGenID()
                                       : SkClipStack::kWideOpenGenID;
    SkColor4f color = paint.getColor4f();
    entry->fColor = {color.fR, color.fG, color.fB, 1};
    entry->fShaderIndex = -1;

    // PDF treats a shader as a color, so we only set one or the other.
    SkShader* shader = paint.getShader();
    if (shader) {
        // note: we always present the alpha as 1 for the shader, knowing that it will be
        //       accounted for when we create our newGraphicsState (below)
        if (SkShader::kColor_GradientType == shader->asAGradient(nullptr)) {
            // We don't have to set a shader just for a color.
            SkShader::GradientInfo gradientInfo;
            SkColor gradientColor = SK_ColorBLACK;
            gradientInfo.fColors = &gradientColor;
            gradientInfo.fColorOffsets = nullptr;
            gradientInfo.fColorCount = 1;
            SkAssertResult(shader->asAGradient(&gradientInfo) == SkShader::kColor_GradientType);
            color = SkColor4f::FromColor(gradientColor);
            entry->fColor ={color.fR, color.fG, color.fB, 1};

        } else {
            // PDF positions patterns relative to the initial transform, so
            // we need to apply the current transform to the shader parameters.
            SkMatrix transform = matrix;
            transform.postConcat(initialTransform);

            // PDF doesn't support kClamp_TileMode, so we simulate it by making
            // a pattern the size of the current clip.
            SkRect clipStackBounds = clipStack ? clipStack->bounds(deviceBounds)
                                               : SkRect::Make(deviceBounds);

            // We need to apply the initial transform to bounds in order to get
            // bounds in a consistent coordinate system.
            initialTransform.mapRect(&clipStackBounds);
            SkIRect bounds;
            clipStackBounds.roundOut(&bounds);

            auto c = paint.getColor4f();
            SkPDFIndirectReference pdfShader = SkPDFMakeShader(doc, shader, transform, bounds,
                                                               {c.fR, c.fG, c.fB, 1.0f});

            if (pdfShader) {
                // pdfShader has been canonicalized so we can directly compare pointers.
                entry->fShaderIndex = add_resource(*shaderResources, pdfShader);
            }
        }
    }

    SkPDFIndirectReference newGraphicState;
    if (color == paint.getColor4f()) {
        newGraphicState = SkPDFGraphicState::GetGraphicStateForPaint(doc, paint);
    } else {
        SkPaint newPaint = paint;
        newPaint.setColor4f(color, nullptr);
        newGraphicState = SkPDFGraphicState::GetGraphicStateForPaint(doc, newPaint);
    }
    entry->fGraphicStateIndex = add_resource(*graphicStateResources, newGraphicState);
    entry->fTextScaleX = textScale;
}

SkDynamicMemoryWStream* SkPDFDevice::setUpContentEntry(const SkClipStack* clipStack,
                                                       const SkMatrix& matrix,
                                                       const SkPaint& paint,
                                                       SkScalar textScale,
                                                       SkPDFIndirectReference* dst) {
    SkASSERT(!*dst);
    SkBlendMode blendMode = paint.getBlendMode_or(SkBlendMode::kSrcOver);

    // Dst xfer mode doesn't draw source at all.
    if (blendMode == SkBlendMode::kDst) {
        return nullptr;
    }

    // For the following modes, we want to handle source and destination
    // separately, so make an object of what's already there.
    if (!treat_as_regular_pdf_blend_mode(blendMode) && blendMode != SkBlendMode::kDstOver) {
        if (!isContentEmpty()) {
            *dst = this->makeFormXObjectFromDevice();
            SkASSERT(isContentEmpty());
        } else if (blendMode != SkBlendMode::kSrc &&
                   blendMode != SkBlendMode::kSrcOut) {
            // Except for Src and SrcOut, if there isn't anything already there,
            // then we're done.
            return nullptr;
        }
    }
    // TODO(vandebo): Figure out how/if we can handle the following modes:
    // Xor, Plus.  For now, we treat them as SrcOver/Normal.

    if (treat_as_regular_pdf_blend_mode(blendMode)) {
        if (!fActiveStackState.fContentStream) {
            if (fContent.bytesWritten() != 0) {
                fContent.writeText(""Q\\nq\\n"");
                fNeedsExtraSave = true;
            }
            fActiveStackState = SkPDFGraphicStackState(&fContent);
        } else {
            SkASSERT(fActiveStackState.fContentStream = &fContent);
        }
    } else {
        fActiveStackState.drainStack();
        fActiveStackState = SkPDFGraphicStackState(&fContentBuffer);
    }
    SkASSERT(fActiveStackState.fContentStream);
    SkPDFGraphicStackState::Entry entry;
    populate_graphic_state_entry_from_paint(
            fDocument,
            matrix,
            clipStack,
            this->bounds(),
            paint,
            fInitialTransform,
            textScale,
            &entry,
            &fShaderResources,
            &fGraphicStateResources);
    fActiveStackState.updateClip(clipStack, this->bounds());
    fActiveStackState.updateMatrix(entry.fMatrix);
    fActiveStackState.updateDrawingState(entry);

    return fActiveStackState.fContentStream;
}

void SkPDFDevice::finishContentEntry(const SkClipStack* clipStack,
                                     SkBlendMode blendMode,
                                     SkPDFIndirectReference dst,
                                     SkPath* shape) {
    SkASSERT(blendMode != SkBlendMode::kDst);
    if (treat_as_regular_pdf_blend_mode(blendMode)) {
        SkASSERT(!dst);
        return;
    }

    SkASSERT(fActiveStackState.fContentStream);

    fActiveStackState.drainStack();
    fActiveStackState = SkPDFGraphicStackState();

    if (blendMode == SkBlendMode::kDstOver) {
        SkASSERT(!dst);
        if (fContentBuffer.bytesWritten() != 0) {
            if (fContent.bytesWritten() != 0) {
                fContentBuffer.writeText(""Q\\nq\\n"");
                fNeedsExtraSave = true;
            }
            fContentBuffer.prependToAndReset(&fContent);
            SkASSERT(fContentBuffer.bytesWritten() == 0);
        }
        return;
    }
    if (fContentBuffer.bytesWritten() != 0) {
        if (fContent.bytesWritten() != 0) {
            fContent.writeText(""Q\\nq\\n"");
            fNeedsExtraSave = true;
        }
        fContentBuffer.writeToAndReset(&fContent);
        SkASSERT(fContentBuffer.bytesWritten() == 0);
    }

    if (!dst) {
        SkASSERT(blendMode == SkBlendMode::kSrc ||
                 blendMode == SkBlendMode::kSrcOut);
        return;
    }

    SkASSERT(dst);
    // Changing the current content into a form-xobject will destroy the clip
    // objects which is fine since the xobject will already be clipped. However
    // if source has shape, we need to clip it too, so a copy of the clip is
    // saved.

    SkPaint stockPaint;

    SkPDFIndirectReference srcFormXObject;
    if (this->isContentEmpty()) {
        // If nothing was drawn and there's no shape, then the draw was a
        // no-op, but dst needs to be restored for that to be true.
        // If there is shape, then an empty source with Src, SrcIn, SrcOut,
        // DstIn, DstAtop or Modulate reduces to Clear and DstOut or SrcAtop
        // reduces to Dst.
        if (shape == nullptr || blendMode == SkBlendMode::kDstOut ||
                blendMode == SkBlendMode::kSrcATop) {
            ScopedContentEntry content(this, nullptr, SkMatrix::I(), stockPaint);
            this->drawFormXObject(dst, content.stream());
            return;
        } else {
            blendMode = SkBlendMode::kClear;
        }
    } else {
        srcFormXObject = this->makeFormXObjectFromDevice();
    }

    // TODO(vandebo) srcFormXObject may contain alpha, but here we want it
    // without alpha.
    if (blendMode == SkBlendMode::kSrcATop) {
        // TODO(vandebo): In order to properly support SrcATop we have to track
        // the shape of what's been drawn at all times. It's the intersection of
        // the non-transparent parts of the device and the outlines (shape) of
        // all images and devices drawn.
        this->drawFormXObjectWithMask(srcFormXObject, dst, SkBlendMode::kSrcOver, true);
    } else {
        if (shape != nullptr) {
            // Draw shape into a form-xobject.
            SkPaint filledPaint;
            filledPaint.setColor(SK_ColorBLACK);
            filledPaint.setStyle(SkPaint::kFill_Style);
            SkClipStack empty;
            SkPDFDevice shapeDev(this->size(), fDocument, fInitialTransform);
            shapeDev.internalDrawPath(clipStack ? *clipStack : empty,
                                      SkMatrix::I(), *shape, filledPaint, true);
            this->drawFormXObjectWithMask(dst, shapeDev.makeFormXObjectFromDevice(),
                                          SkBlendMode::kSrcOver, true);
        } else {
            this->drawFormXObjectWithMask(dst, srcFormXObject, SkBlendMode::kSrcOver, true);
        }
    }

    if (blendMode == SkBlendMode::kClear) {
        return;
    } else if (blendMode == SkBlendMode::kSrc ||
            blendMode == SkBlendMode::kDstATop) {
        ScopedContentEntry content(this, nullptr, SkMatrix::I(), stockPaint);
        if (content) {
            this->drawFormXObject(srcFormXObject, content.stream());
        }
        if (blendMode == SkBlendMode::kSrc) {
            return;
        }
    } else if (blendMode == SkBlendMode::kSrcATop) {
        ScopedContentEntry content(this, nullptr, SkMatrix::I(), stockPaint);
        if (content) {
            this->drawFormXObject(dst, content.stream());
        }
    }

    SkASSERT(blendMode == SkBlendMode::kSrcIn   ||
             blendMode == SkBlendMode::kDstIn   ||
             blendMode == SkBlendMode::kSrcOut  ||
             blendMode == SkBlendMode::kDstOut  ||
             blendMode == SkBlendMode::kSrcATop ||
             blendMode == SkBlendMode::kDstATop ||
             blendMode == SkBlendMode::kModulate);

    if (blendMode == SkBlendMode::kSrcIn ||
            blendMode == SkBlendMode::kSrcOut ||
            blendMode == SkBlendMode::kSrcATop) {
        this->drawFormXObjectWithMask(srcFormXObject, dst, SkBlendMode::kSrcOver,
                                      blendMode == SkBlendMode::kSrcOut);
        return;
    } else {
        SkBlendMode mode = SkBlendMode::kSrcOver;
        if (blendMode == SkBlendMode::kModulate) {
            this->drawFormXObjectWithMask(srcFormXObject, dst, SkBlendMode::kSrcOver, false);
            mode = SkBlendMode::kMultiply;
        }
        this->drawFormXObjectWithMask(dst, srcFormXObject, mode, blendMode == SkBlendMode::kDstOut);
        return;
    }
}

bool SkPDFDevice::isContentEmpty() {
    return fContent.bytesWritten() == 0 && fContentBuffer.bytesWritten() == 0;
}

static SkSize rect_to_size(const SkRect& r) { return {r.width(), r.height()}; }

static sk_sp<SkImage> color_filter(const SkImage* image,
                                   SkColorFilter* colorFilter) {
    auto surface =
        SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(image->dimensions()));
    SkASSERT(surface);
    SkCanvas* canvas = surface->getCanvas();
    canvas->clear(SK_ColorTRANSPARENT);
    SkPaint paint;
    paint.setColorFilter(sk_ref_sp(colorFilter));
    canvas->drawImage(image, 0, 0, SkSamplingOptions(), &paint);
    return surface->makeImageSnapshot();
}

////////////////////////////////////////////////////////////////////////////////

static bool is_integer(SkScalar x) {
    return x == SkScalarTruncToScalar(x);
}

static bool is_integral(const SkRect& r) {
    return is_integer(r.left()) &&
           is_integer(r.top()) &&
           is_integer(r.right()) &&
           is_integer(r.bottom());
}

void SkPDFDevice::internalDrawImageRect(SkKeyedImage imageSubset,
                                        const SkRect* src,
                                        const SkRect& dst,
                                        const SkSamplingOptions& sampling,
                                        const SkPaint& srcPaint,
                                        const SkMatrix& ctm) {
    if (this->hasEmptyClip()) {
        return;
    }
    if (!imageSubset) {
        return;
    }

    // First, figure out the src->dst transform and subset the image if needed.
    SkIRect bounds = imageSubset.image()->bounds();
    SkRect srcRect = src ? *src : SkRect::Make(bounds);
    SkMatrix transform = SkMatrix::RectToRect(srcRect, dst);
    if (src && *src != SkRect::Make(bounds)) {
        if (!srcRect.intersect(SkRect::Make(bounds))) {
            return;
        }
        srcRect.roundOut(&bounds);
        transform.preTranslate(SkIntToScalar(bounds.x()),
                               SkIntToScalar(bounds.y()));
        if (bounds != imageSubset.image()->bounds()) {
            imageSubset = imageSubset.subset(bounds);
        }
        if (!imageSubset) {
            return;
        }
    }

    // If the image is opaque and the paint's alpha is too, replace
    // kSrc blendmode with kSrcOver.  http://crbug.com/473572
    SkTCopyOnFirstWrite<SkPaint> paint(srcPaint);
    if (!paint->isSrcOver() &&
        imageSubset.image()->isOpaque() &&
        kSrcOver_SkXfermodeInterpretation == SkInterpretXfermode(*paint, false))
    {
        paint.writable()->setBlendMode(SkBlendMode::kSrcOver);
    }

    // Alpha-only images need to get their color from the shader, before
    // applying the colorfilter.
    if (imageSubset.image()->isAlphaOnly() && paint->getColorFilter()) {
        // must blend alpha image and shader before applying colorfilter.
        auto surface =
            SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(imageSubset.image()->dimensions()));
        SkCanvas* canvas = surface->getCanvas();
        SkPaint tmpPaint;
        // In the case of alpha images with shaders, the shader's coordinate
        // system is the image's coordiantes.
        tmpPaint.setShader(sk_ref_sp(paint->getShader()));
        tmpPaint.setColor4f(paint->getColor4f(), nullptr);
        canvas->clear(0x00000000);
        canvas->drawImage(imageSubset.image().get(), 0, 0, sampling, &tmpPaint);
        if (paint->getShader() != nullptr) {
            paint.writable()->setShader(nullptr);
        }
        imageSubset = SkKeyedImage(surface->makeImageSnapshot());
        SkASSERT(!imageSubset.image()->isAlphaOnly());
    }

    if (imageSubset.image()->isAlphaOnly()) {
        // The ColorFilter applies to the paint color/shader, not the alpha layer.
        SkASSERT(nullptr == paint->getColorFilter());

        sk_sp<SkImage> mask = alpha_image_to_greyscale_image(imageSubset.image().get());
        if (!mask) {
            return;
        }
        // PDF doesn't seem to allow masking vector graphics with an Image XObject.
        // Must mask with a Form XObject.
        sk_sp<SkPDFDevice> maskDevice = this->makeCongruentDevice();
        {
            SkCanvas canvas(maskDevice);
            // This clip prevents the mask image shader from covering
            // entire device if unnecessary.
            canvas.clipRect(this->cs().bounds(this->bounds()));
            canvas.concat(ctm);
            if (paint->getMaskFilter()) {
                SkPaint tmpPaint;
                tmpPaint.setShader(mask->makeShader(SkSamplingOptions(), transform));
                tmpPaint.setMaskFilter(sk_ref_sp(paint->getMaskFilter()));
                canvas.drawRect(dst, tmpPaint);
            } else {
                if (src && !is_integral(*src)) {
                    canvas.clipRect(dst);
                }
                canvas.concat(transform);
                canvas.drawImage(mask, 0, 0);
            }
        }
        SkIRect maskDeviceBounds = maskDevice->cs().bounds(maskDevice->bounds()).roundOut();
        if (!ctm.isIdentity() && paint->getShader()) {
            transform_shader(paint.writable(), ctm); // Since we are using identity matrix.
        }
        ScopedContentEntry content(this, &this->cs(), SkMatrix::I(), *paint);
        if (!content) {
            return;
        }
        this->setGraphicState(SkPDFGraphicState::GetSMaskGraphicState(
                maskDevice->makeFormXObjectFromDevice(maskDeviceBounds, true), false,
                SkPDFGraphicState::kLuminosity_SMaskMode, fDocument), content.stream());
        SkPDFUtils::AppendRectangle(SkRect::Make(this->size()), content.stream());
        SkPDFUtils::PaintPath(SkPaint::kFill_Style, SkPathFillType::kWinding, content.stream());
        this->clearMaskOnGraphicState(content.stream());
        return;
    }
    if (paint->getMaskFilter()) {
        paint.writable()->setShader(imageSubset.image()->makeShader(SkSamplingOptions(),
                                                                    transform));
        SkPath path = SkPath::Rect(dst); // handles non-integral clipping.
        this->internalDrawPath(this->cs(), this->localToDevice(), path, *paint, true);
        return;
    }
    transform.postConcat(ctm);

    bool needToRestore = false;
    if (src && !is_integral(*src)) {
        // Need sub-pixel clipping to fix https://bug.skia.org/4374
        this->cs().save();
        this->cs().clipRect(dst, ctm, SkClipOp::kIntersect, true);
        needToRestore = true;
    }
    SK_AT_SCOPE_EXIT(if (needToRestore) { this->cs().restore(); });

    SkMatrix matrix = transform;

    // Rasterize the bitmap using perspective in a new bitmap.
    if (transform.hasPerspective()) {
        // Transform the bitmap in the new space, without taking into
        // account the initial transform.
        SkRect imageBounds = SkRect::Make(imageSubset.image()->bounds());
        SkPath perspectiveOutline = SkPath::Rect(imageBounds).makeTransform(transform);

        // Retrieve the bounds of the new shape.
        SkRect outlineBounds = perspectiveOutline.getBounds();
        if (!outlineBounds.intersect(SkRect::Make(this->devClipBounds()))) {
            return;
        }

        // Transform the bitmap in the new space to the final space, to account for DPI
        SkRect physicalBounds = fInitialTransform.mapRect(outlineBounds);
        SkScalar scaleX = physicalBounds.width() / outlineBounds.width();
        SkScalar scaleY = physicalBounds.height() / outlineBounds.height();

        // TODO(edisonn): A better approach would be to use a bitmap shader
        // (in clamp mode) and draw a rect over the entire bounding box. Then
        // intersect perspectiveOutline to the clip. That will avoid introducing
        // alpha to the image while still giving good behavior at the edge of
        // the image.  Avoiding alpha will reduce the pdf size and generation
        // CPU time some.

        SkISize wh = rect_to_size(physicalBounds).toCeil();

        auto surface = SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(wh));
        if (!surface) {
            return;
        }
        SkCanvas* canvas = surface->getCanvas();
        canvas->clear(SK_ColorTRANSPARENT);

        SkScalar deltaX = outlineBounds.left();
        SkScalar deltaY = outlineBounds.top();

        SkMatrix offsetMatrix = transform;
        offsetMatrix.postTranslate(-deltaX, -deltaY);
        offsetMatrix.postScale(scaleX, scaleY);

        // Translate the draw in the new canvas, so we perfectly fit the
        // shape in the bitmap.
        canvas->setMatrix(offsetMatrix);
        canvas->drawImage(imageSubset.image(), 0, 0);
        // Make sure the final bits are in the bitmap.
        surface->flushAndSubmit();

        // In the new space, we use the identity matrix translated
        // and scaled to reflect DPI.
        matrix.setScale(1 / scaleX, 1 / scaleY);
        matrix.postTranslate(deltaX, deltaY);

        imageSubset = SkKeyedImage(surface->makeImageSnapshot());
        if (!imageSubset) {
            return;
        }
    }

    SkMatrix scaled;
    // Adjust for origin flip.
    scaled.setScale(SK_Scalar1, -SK_Scalar1);
    scaled.postTranslate(0, SK_Scalar1);
    // Scale the image up from 1x1 to WxH.
    SkIRect subset = imageSubset.image()->bounds();
    scaled.postScale(SkIntToScalar(subset.width()),
                     SkIntToScalar(subset.height()));
    scaled.postConcat(matrix);
    ScopedContentEntry content(this, &this->cs(), scaled, *paint);
    if (!content) {
        return;
    }
    if (content.needShape()) {
        SkPath shape = SkPath::Rect(SkRect::Make(subset)).makeTransform(matrix);
        content.setShape(shape);
    }
    if (!content.needSource()) {
        return;
    }

    if (SkColorFilter* colorFilter = paint->getColorFilter()) {
        sk_sp<SkImage> img = color_filter(imageSubset.image().get(), colorFilter);
        imageSubset = SkKeyedImage(std::move(img));
        if (!imageSubset) {
            return;
        }
        // TODO(halcanary): de-dupe this by caching filtered images.
        // (maybe in the resource cache?)
    }

    SkBitmapKey key = imageSubset.key();
    SkPDFIndirectReference* pdfimagePtr = fDocument->fPDFBitmapMap.find(key);
    SkPDFIndirectReference pdfimage = pdfimagePtr ? *pdfimagePtr : SkPDFIndirectReference();
    if (!pdfimagePtr) {
        SkASSERT(imageSubset);
        pdfimage = SkPDFSerializeImage(imageSubset.image().get(), fDocument,
                                       fDocument->metadata().fEncodingQuality);
        SkASSERT((key != SkBitmapKey{{0, 0, 0, 0}, 0}));
        fDocument->fPDFBitmapMap.set(key, pdfimage);
    }
    SkASSERT(pdfimage != SkPDFIndirectReference());
    this->drawFormXObject(pdfimage, content.stream());
}

///////////////////////////////////////////////////////////////////////////////////////////////////


void SkPDFDevice::drawDevice(SkBaseDevice* device, const SkSamplingOptions& sampling,
                             const SkPaint& paint) {
    SkASSERT(!paint.getImageFilter());
    SkASSERT(!paint.getMaskFilter());

    // Check if the source device is really a bitmapdevice (because that's what we returned
    // from createDevice (an image filter would go through drawSpecial, but createDevice uses
    // a raster device to apply color filters, too).
    SkPixmap pmap;
    if (device->peekPixels(&pmap)) {
        this->INHERITED::drawDevice(device, sampling, paint);
        return;
    }

    // our onCreateCompatibleDevice() always creates SkPDFDevice subclasses.
    SkPDFDevice* pdfDevice = static_cast<SkPDFDevice*>(device);

    if (pdfDevice->isContentEmpty()) {
        return;
    }

    SkMatrix matrix = device->getRelativeTransform(*this);
    ScopedContentEntry content(this, &this->cs(), matrix, paint);
    if (!content) {
        return;
    }
    if (content.needShape()) {
        SkPath shape = SkPath::Rect(SkRect::Make(device->imageInfo().dimensions()));
        shape.transform(matrix);
        content.setShape(shape);
    }
    if (!content.needSource()) {
        return;
    }
    this->drawFormXObject(pdfDevice->makeFormXObjectFromDevice(), content.stream());
}

void SkPDFDevice::drawSpecial(SkSpecialImage* srcImg, const SkMatrix& localToDevice,
                              const SkSamplingOptions& sampling, const SkPaint& paint) {
    if (this->hasEmptyClip()) {
        return;
    }
    SkASSERT(!srcImg->isTextureBacked());
    SkASSERT(!paint.getMaskFilter() && !paint.getImageFilter());

    SkBitmap resultBM;
    if (srcImg->getROPixels(&resultBM)) {
        auto r = SkRect::MakeWH(resultBM.width(), resultBM.height());
        this->internalDrawImageRect(SkKeyedImage(resultBM), nullptr, r, sampling, paint,
                                    localToDevice);
    }
}

sk_sp<SkSpecialImage> SkPDFDevice::makeSpecial(const SkBitmap& bitmap) {
    return SkSpecialImage::MakeFromRaster(bitmap.bounds(), bitmap, this->surfaceProps());
}

sk_sp<SkSpecialImage> SkPDFDevice::makeSpecial(const SkImage* image) {
    return SkSpecialImage::MakeFromImage(nullptr, image->bounds(), image->makeNonTextureImage(),
                                         this->surfaceProps());
}

SkImageFilterCache* SkPDFDevice::getImageFilterCache() {
    // We always return a transient cache, so it is freed after each
    // filter traversal.
    return SkImageFilterCache::Create(SkImageFilterCache::kDefaultTransientSize);
}
",16229,True,3087.5574361938975,median
"#include <nano/lib/rep_weights.hpp>
#include <nano/lib/stats.hpp>
#include <nano/lib/utility.hpp>
#include <nano/lib/work.hpp>
#include <nano/secure/blockstore.hpp>
#include <nano/secure/common.hpp>
#include <nano/secure/ledger.hpp>

#include <crypto/cryptopp/words.h>

namespace
{
/**
 * Roll back the visited block
 */
class rollback_visitor : public nano::block_visitor
{
public:
	rollback_visitor (nano::write_transaction const & transaction_a, nano::ledger & ledger_a, std::vector<std::shared_ptr<nano::block>> & list_a) :
	transaction (transaction_a),
	ledger (ledger_a),
	list (list_a)
	{
	}
	virtual ~rollback_visitor () = default;
	void send_block (nano::send_block const & block_a) override
	{
		auto hash (block_a.hash ());
		nano::pending_info pending;
		nano::pending_key key (block_a.hashables.destination, hash);
		while (!error && ledger.store.pending_get (transaction, key, pending))
		{
			error = ledger.rollback (transaction, ledger.latest (transaction, block_a.hashables.destination), list);
		}
		if (!error)
		{
			nano::account_info info;
			[[maybe_unused]] auto error (ledger.store.account_get (transaction, pending.source, info));
			debug_assert (!error);
			ledger.store.pending_del (transaction, key);
			ledger.cache.rep_weights.representation_add (info.representative, pending.amount.number ());
			nano::account_info new_info (block_a.hashables.previous, info.representative, info.open_block, ledger.balance (transaction, block_a.hashables.previous), nano::seconds_since_epoch (), info.block_count - 1, nano::epoch::epoch_0);
			ledger.update_account (transaction, pending.source, info, new_info);
			ledger.store.block_del (transaction, hash);
			ledger.store.frontier_del (transaction, hash);
			ledger.store.frontier_put (transaction, block_a.hashables.previous, pending.source);
			ledger.store.block_successor_clear (transaction, block_a.hashables.previous);
			ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::send);
		}
	}
	void receive_block (nano::receive_block const & block_a) override
	{
		auto hash (block_a.hash ());
		auto amount (ledger.amount (transaction, hash));
		auto destination_account (ledger.account (transaction, hash));
		// Pending account entry can be incorrect if source block was pruned. But it's not affecting correct ledger processing
		[[maybe_unused]] bool is_pruned (false);
		auto source_account (ledger.account_safe (transaction, block_a.hashables.source, is_pruned));
		nano::account_info info;
		[[maybe_unused]] auto error (ledger.store.account_get (transaction, destination_account, info));
		debug_assert (!error);
		ledger.cache.rep_weights.representation_add (info.representative, 0 - amount);
		nano::account_info new_info (block_a.hashables.previous, info.representative, info.open_block, ledger.balance (transaction, block_a.hashables.previous), nano::seconds_since_epoch (), info.block_count - 1, nano::epoch::epoch_0);
		ledger.update_account (transaction, destination_account, info, new_info);
		ledger.store.block_del (transaction, hash);
		ledger.store.pending_put (transaction, nano::pending_key (destination_account, block_a.hashables.source), { source_account, amount, nano::epoch::epoch_0 });
		ledger.store.frontier_del (transaction, hash);
		ledger.store.frontier_put (transaction, block_a.hashables.previous, destination_account);
		ledger.store.block_successor_clear (transaction, block_a.hashables.previous);
		ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::receive);
	}
	void open_block (nano::open_block const & block_a) override
	{
		auto hash (block_a.hash ());
		auto amount (ledger.amount (transaction, hash));
		auto destination_account (ledger.account (transaction, hash));
		// Pending account entry can be incorrect if source block was pruned. But it's not affecting correct ledger processing
		[[maybe_unused]] bool is_pruned (false);
		auto source_account (ledger.account_safe (transaction, block_a.hashables.source, is_pruned));
		ledger.cache.rep_weights.representation_add (block_a.representative (), 0 - amount);
		nano::account_info new_info;
		ledger.update_account (transaction, destination_account, new_info, new_info);
		ledger.store.block_del (transaction, hash);
		ledger.store.pending_put (transaction, nano::pending_key (destination_account, block_a.hashables.source), { source_account, amount, nano::epoch::epoch_0 });
		ledger.store.frontier_del (transaction, hash);
		ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::open);
	}
	void change_block (nano::change_block const & block_a) override
	{
		auto hash (block_a.hash ());
		auto rep_block (ledger.representative (transaction, block_a.hashables.previous));
		auto account (ledger.account (transaction, block_a.hashables.previous));
		nano::account_info info;
		[[maybe_unused]] auto error (ledger.store.account_get (transaction, account, info));
		debug_assert (!error);
		auto balance (ledger.balance (transaction, block_a.hashables.previous));
		auto block = ledger.store.block_get (transaction, rep_block);
		release_assert (block != nullptr);
		auto representative = block->representative ();
		ledger.cache.rep_weights.representation_add_dual (block_a.representative (), 0 - balance, representative, balance);
		ledger.store.block_del (transaction, hash);
		nano::account_info new_info (block_a.hashables.previous, representative, info.open_block, info.balance, nano::seconds_since_epoch (), info.block_count - 1, nano::epoch::epoch_0);
		ledger.update_account (transaction, account, info, new_info);
		ledger.store.frontier_del (transaction, hash);
		ledger.store.frontier_put (transaction, block_a.hashables.previous, account);
		ledger.store.block_successor_clear (transaction, block_a.hashables.previous);
		ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::change);
	}
	void state_block (nano::state_block const & block_a) override
	{
		auto hash (block_a.hash ());
		nano::block_hash rep_block_hash (0);
		if (!block_a.hashables.previous.is_zero ())
		{
			rep_block_hash = ledger.representative (transaction, block_a.hashables.previous);
		}
		auto balance (ledger.balance (transaction, block_a.hashables.previous));
		auto is_send (block_a.hashables.balance < balance);
		nano::account representative{ 0 };
		if (!rep_block_hash.is_zero ())
		{
			// Move existing representation & add in amount delta
			auto block (ledger.store.block_get (transaction, rep_block_hash));
			debug_assert (block != nullptr);
			representative = block->representative ();
			ledger.cache.rep_weights.representation_add_dual (representative, balance, block_a.representative (), 0 - block_a.hashables.balance.number ());
		}
		else
		{
			// Add in amount delta only
			ledger.cache.rep_weights.representation_add (block_a.representative (), 0 - block_a.hashables.balance.number ());
		}

		nano::account_info info;
		auto error (ledger.store.account_get (transaction, block_a.hashables.account, info));

		if (is_send)
		{
			nano::pending_key key (block_a.hashables.link.as_account (), hash);
			while (!error && !ledger.store.pending_exists (transaction, key))
			{
				error = ledger.rollback (transaction, ledger.latest (transaction, block_a.hashables.link.as_account ()), list);
			}
			ledger.store.pending_del (transaction, key);
			ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::send);
		}
		else if (!block_a.hashables.link.is_zero () && !ledger.is_epoch_link (block_a.hashables.link))
		{
			// Pending account entry can be incorrect if source block was pruned. But it's not affecting correct ledger processing
			[[maybe_unused]] bool is_pruned (false);
			auto source_account (ledger.account_safe (transaction, block_a.hashables.link.as_block_hash (), is_pruned));
			nano::pending_info pending_info (source_account, block_a.hashables.balance.number () - balance, block_a.sideband ().source_epoch);
			ledger.store.pending_put (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link.as_block_hash ()), pending_info);
			ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::receive);
		}

		debug_assert (!error);
		auto previous_version (ledger.store.block_version (transaction, block_a.hashables.previous));
		nano::account_info new_info (block_a.hashables.previous, representative, info.open_block, balance, nano::seconds_since_epoch (), info.block_count - 1, previous_version);
		ledger.update_account (transaction, block_a.hashables.account, info, new_info);

		auto previous (ledger.store.block_get (transaction, block_a.hashables.previous));
		if (previous != nullptr)
		{
			ledger.store.block_successor_clear (transaction, block_a.hashables.previous);
			if (previous->type () < nano::block_type::state)
			{
				ledger.store.frontier_put (transaction, block_a.hashables.previous, block_a.hashables.account);
			}
		}
		else
		{
			ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::open);
		}
		ledger.store.block_del (transaction, hash);
	}
	nano::write_transaction const & transaction;
	nano::ledger & ledger;
	std::vector<std::shared_ptr<nano::block>> & list;
	bool error{ false };
};

class ledger_processor : public nano::mutable_block_visitor
{
public:
	ledger_processor (nano::ledger &, nano::write_transaction const &, nano::signature_verification = nano::signature_verification::unknown);
	virtual ~ledger_processor () = default;
	void send_block (nano::send_block &) override;
	void receive_block (nano::receive_block &) override;
	void open_block (nano::open_block &) override;
	void change_block (nano::change_block &) override;
	void state_block (nano::state_block &) override;
	void state_block_impl (nano::state_block &);
	void epoch_block_impl (nano::state_block &);
	nano::ledger & ledger;
	nano::write_transaction const & transaction;
	nano::signature_verification verification;
	nano::process_return result;

private:
	bool validate_epoch_block (nano::state_block const & block_a);
};

// Returns true if this block which has an epoch link is correctly formed.
bool ledger_processor::validate_epoch_block (nano::state_block const & block_a)
{
	debug_assert (ledger.is_epoch_link (block_a.hashables.link));
	nano::amount prev_balance (0);
	if (!block_a.hashables.previous.is_zero ())
	{
		result.code = ledger.store.block_exists (transaction, block_a.hashables.previous) ? nano::process_result::progress : nano::process_result::gap_previous;
		if (result.code == nano::process_result::progress)
		{
			prev_balance = ledger.balance (transaction, block_a.hashables.previous);
		}
		else if (result.verified == nano::signature_verification::unknown)
		{
			// Check for possible regular state blocks with epoch link (send subtype)
			if (validate_message (block_a.hashables.account, block_a.hash (), block_a.signature))
			{
				// Is epoch block signed correctly
				if (validate_message (ledger.epoch_signer (block_a.link ()), block_a.hash (), block_a.signature))
				{
					result.verified = nano::signature_verification::invalid;
					result.code = nano::process_result::bad_signature;
				}
				else
				{
					result.verified = nano::signature_verification::valid_epoch;
				}
			}
			else
			{
				result.verified = nano::signature_verification::valid;
			}
		}
	}
	return (block_a.hashables.balance == prev_balance);
}

void ledger_processor::state_block (nano::state_block & block_a)
{
	result.code = nano::process_result::progress;
	auto is_epoch_block = false;
	if (ledger.is_epoch_link (block_a.hashables.link))
	{
		// This function also modifies the result variable if epoch is mal-formed
		is_epoch_block = validate_epoch_block (block_a);
	}

	if (result.code == nano::process_result::progress)
	{
		if (is_epoch_block)
		{
			epoch_block_impl (block_a);
		}
		else
		{
			state_block_impl (block_a);
		}
	}
}

void ledger_processor::state_block_impl (nano::state_block & block_a)
{
	auto hash (block_a.hash ());
	auto existing (ledger.block_or_pruned_exists (transaction, hash));
	result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Unambiguous)
	if (result.code == nano::process_result::progress)
	{
		// Validate block if not verified outside of ledger
		if (result.verified != nano::signature_verification::valid)
		{
			result.code = validate_message (block_a.hashables.account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is this block signed correctly (Unambiguous)
		}
		if (result.code == nano::process_result::progress)
		{
			debug_assert (!validate_message (block_a.hashables.account, hash, block_a.signature));
			result.verified = nano::signature_verification::valid;
			result.code = block_a.hashables.account.is_zero () ? nano::process_result::opened_burn_account : nano::process_result::progress; // Is this for the burn account? (Unambiguous)
			if (result.code == nano::process_result::progress)
			{
				nano::epoch epoch (nano::epoch::epoch_0);
				nano::epoch source_epoch (nano::epoch::epoch_0);
				nano::account_info info;
				nano::amount amount (block_a.hashables.balance);
				auto is_send (false);
				auto is_receive (false);
				auto account_error (ledger.store.account_get (transaction, block_a.hashables.account, info));
				if (!account_error)
				{
					// Account already exists
					epoch = info.epoch ();
					result.previous_balance = info.balance;
					result.code = block_a.hashables.previous.is_zero () ? nano::process_result::fork : nano::process_result::progress; // Has this account already been opened? (Ambigious)
					if (result.code == nano::process_result::progress)
					{
						result.code = ledger.store.block_exists (transaction, block_a.hashables.previous) ? nano::process_result::progress : nano::process_result::gap_previous; // Does the previous block exist in the ledger? (Unambigious)
						if (result.code == nano::process_result::progress)
						{
							is_send = block_a.hashables.balance < info.balance;
							is_receive = !is_send && !block_a.hashables.link.is_zero ();
							amount = is_send ? (info.balance.number () - amount.number ()) : (amount.number () - info.balance.number ());
							result.code = block_a.hashables.previous == info.head ? nano::process_result::progress : nano::process_result::fork; // Is the previous block the account's head block? (Ambigious)
						}
					}
				}
				else
				{
					// Account does not yet exists
					result.previous_balance = 0;
					result.code = block_a.previous ().is_zero () ? nano::process_result::progress : nano::process_result::gap_previous; // Does the first block in an account yield 0 for previous() ? (Unambigious)
					if (result.code == nano::process_result::progress)
					{
						is_receive = true;
						result.code = !block_a.hashables.link.is_zero () ? nano::process_result::progress : nano::process_result::gap_source; // Is the first block receiving from a send ? (Unambigious)
					}
				}
				if (result.code == nano::process_result::progress)
				{
					if (!is_send)
					{
						if (!block_a.hashables.link.is_zero ())
						{
							result.code = ledger.block_or_pruned_exists (transaction, block_a.hashables.link.as_block_hash ()) ? nano::process_result::progress : nano::process_result::gap_source; // Have we seen the source block already? (Harmless)
							if (result.code == nano::process_result::progress)
							{
								nano::pending_key key (block_a.hashables.account, block_a.hashables.link.as_block_hash ());
								nano::pending_info pending;
								result.code = ledger.store.pending_get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed)
								if (result.code == nano::process_result::progress)
								{
									result.code = amount == pending.amount ? nano::process_result::progress : nano::process_result::balance_mismatch;
									source_epoch = pending.epoch;
									epoch = std::max (epoch, source_epoch);
								}
							}
						}
						else
						{
							// If there's no link, the balance must remain the same, only the representative can change
							result.code = amount.is_zero () ? nano::process_result::progress : nano::process_result::balance_mismatch;
						}
					}
				}
				if (result.code == nano::process_result::progress)
				{
					nano::block_details block_details (epoch, is_send, is_receive, false);
					result.code = block_a.difficulty () >= nano::work_threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed)
					if (result.code == nano::process_result::progress)
					{
						ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::state_block);
						block_a.sideband_set (nano::block_sideband (block_a.hashables.account /* unused */, 0, 0 /* unused */, info.block_count + 1, nano::seconds_since_epoch (), block_details, source_epoch));
						ledger.store.block_put (transaction, hash, block_a);

						if (!info.head.is_zero ())
						{
							// Move existing representation & add in amount delta
							ledger.cache.rep_weights.representation_add_dual (info.representative, 0 - info.balance.number (), block_a.representative (), block_a.hashables.balance.number ());
						}
						else
						{
							// Add in amount delta only
							ledger.cache.rep_weights.representation_add (block_a.representative (), block_a.hashables.balance.number ());
						}

						if (is_send)
						{
							nano::pending_key key (block_a.hashables.link.as_account (), hash);
							nano::pending_info info (block_a.hashables.account, amount.number (), epoch);
							ledger.store.pending_put (transaction, key, info);
						}
						else if (!block_a.hashables.link.is_zero ())
						{
							ledger.store.pending_del (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link.as_block_hash ()));
						}

						nano::account_info new_info (hash, block_a.representative (), info.open_block.is_zero () ? hash : info.open_block, block_a.hashables.balance, nano::seconds_since_epoch (), info.block_count + 1, epoch);
						ledger.update_account (transaction, block_a.hashables.account, info, new_info);
						if (!ledger.store.frontier_get (transaction, info.head).is_zero ())
						{
							ledger.store.frontier_del (transaction, info.head);
						}
					}
				}
			}
		}
	}
}

void ledger_processor::epoch_block_impl (nano::state_block & block_a)
{
	auto hash (block_a.hash ());
	auto existing (ledger.block_or_pruned_exists (transaction, hash));
	result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Unambiguous)
	if (result.code == nano::process_result::progress)
	{
		// Validate block if not verified outside of ledger
		if (result.verified != nano::signature_verification::valid_epoch)
		{
			result.code = validate_message (ledger.epoch_signer (block_a.hashables.link), hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is this block signed correctly (Unambiguous)
		}
		if (result.code == nano::process_result::progress)
		{
			debug_assert (!validate_message (ledger.epoch_signer (block_a.hashables.link), hash, block_a.signature));
			result.verified = nano::signature_verification::valid_epoch;
			result.code = block_a.hashables.account.is_zero () ? nano::process_result::opened_burn_account : nano::process_result::progress; // Is this for the burn account? (Unambiguous)
			if (result.code == nano::process_result::progress)
			{
				nano::account_info info;
				auto account_error (ledger.store.account_get (transaction, block_a.hashables.account, info));
				if (!account_error)
				{
					// Account already exists
					result.previous_balance = info.balance;
					result.code = block_a.hashables.previous.is_zero () ? nano::process_result::fork : nano::process_result::progress; // Has this account already been opened? (Ambigious)
					if (result.code == nano::process_result::progress)
					{
						result.code = block_a.hashables.previous == info.head ? nano::process_result::progress : nano::process_result::fork; // Is the previous block the account's head block? (Ambigious)
						if (result.code == nano::process_result::progress)
						{
							result.code = block_a.hashables.representative == info.representative ? nano::process_result::progress : nano::process_result::representative_mismatch;
						}
					}
				}
				else
				{
					result.previous_balance = 0;
					result.code = block_a.hashables.representative.is_zero () ? nano::process_result::progress : nano::process_result::representative_mismatch;
					// Non-exisitng account should have pending entries
					if (result.code == nano::process_result::progress)
					{
						bool pending_exists = ledger.store.pending_any (transaction, block_a.hashables.account);
						result.code = pending_exists ? nano::process_result::progress : nano::process_result::block_position;
					}
				}
				if (result.code == nano::process_result::progress)
				{
					auto epoch = ledger.network_params.ledger.epochs.epoch (block_a.hashables.link);
					// Must be an epoch for an unopened account or the epoch upgrade must be sequential
					auto is_valid_epoch_upgrade = account_error ? static_cast<std::underlying_type_t<nano::epoch>> (epoch) > 0 : nano::epochs::is_sequential (info.epoch (), epoch);
					result.code = is_valid_epoch_upgrade ? nano::process_result::progress : nano::process_result::block_position;
					if (result.code == nano::process_result::progress)
					{
						result.code = block_a.hashables.balance == info.balance ? nano::process_result::progress : nano::process_result::balance_mismatch;
						if (result.code == nano::process_result::progress)
						{
							nano::block_details block_details (epoch, false, false, true);
							result.code = block_a.difficulty () >= nano::work_threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed)
							if (result.code == nano::process_result::progress)
							{
								ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::epoch_block);
								block_a.sideband_set (nano::block_sideband (block_a.hashables.account /* unused */, 0, 0 /* unused */, info.block_count + 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */));
								ledger.store.block_put (transaction, hash, block_a);
								nano::account_info new_info (hash, block_a.representative (), info.open_block.is_zero () ? hash : info.open_block, info.balance, nano::seconds_since_epoch (), info.block_count + 1, epoch);
								ledger.update_account (transaction, block_a.hashables.account, info, new_info);
								if (!ledger.store.frontier_get (transaction, info.head).is_zero ())
								{
									ledger.store.frontier_del (transaction, info.head);
								}
							}
						}
					}
				}
			}
		}
	}
}

void ledger_processor::change_block (nano::change_block & block_a)
{
	auto hash (block_a.hash ());
	auto existing (ledger.block_or_pruned_exists (transaction, hash));
	result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Harmless)
	if (result.code == nano::process_result::progress)
	{
		auto previous (ledger.store.block_get (transaction, block_a.hashables.previous));
		result.code = previous != nullptr ? nano::process_result::progress : nano::process_result::gap_previous; // Have we seen the previous block already? (Harmless)
		if (result.code == nano::process_result::progress)
		{
			result.code = block_a.valid_predecessor (*previous) ? nano::process_result::progress : nano::process_result::block_position;
			if (result.code == nano::process_result::progress)
			{
				auto account (ledger.store.frontier_get (transaction, block_a.hashables.previous));
				result.code = account.is_zero () ? nano::process_result::fork : nano::process_result::progress;
				if (result.code == nano::process_result::progress)
				{
					nano::account_info info;
					auto latest_error (ledger.store.account_get (transaction, account, info));
					(void)latest_error;
					debug_assert (!latest_error);
					debug_assert (info.head == block_a.hashables.previous);
					// Validate block if not verified outside of ledger
					if (result.verified != nano::signature_verification::valid)
					{
						result.code = validate_message (account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is this block signed correctly (Malformed)
					}
					if (result.code == nano::process_result::progress)
					{
						nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */);
						result.code = block_a.difficulty () >= nano::work_threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed)
						if (result.code == nano::process_result::progress)
						{
							debug_assert (!validate_message (account, hash, block_a.signature));
							result.verified = nano::signature_verification::valid;
							block_a.sideband_set (nano::block_sideband (account, 0, info.balance, info.block_count + 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */));
							ledger.store.block_put (transaction, hash, block_a);
							auto balance (ledger.balance (transaction, block_a.hashables.previous));
							ledger.cache.rep_weights.representation_add_dual (block_a.representative (), balance, info.representative, 0 - balance);
							nano::account_info new_info (hash, block_a.representative (), info.open_block, info.balance, nano::seconds_since_epoch (), info.block_count + 1, nano::epoch::epoch_0);
							ledger.update_account (transaction, account, info, new_info);
							ledger.store.frontier_del (transaction, block_a.hashables.previous);
							ledger.store.frontier_put (transaction, hash, account);
							result.previous_balance = info.balance;
							ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::change);
						}
					}
				}
			}
		}
	}
}

void ledger_processor::send_block (nano::send_block & block_a)
{
	auto hash (block_a.hash ());
	auto existing (ledger.block_or_pruned_exists (transaction, hash));
	result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Harmless)
	if (result.code == nano::process_result::progress)
	{
		auto previous (ledger.store.block_get (transaction, block_a.hashables.previous));
		result.code = previous != nullptr ? nano::process_result::progress : nano::process_result::gap_previous; // Have we seen the previous block already? (Harmless)
		if (result.code == nano::process_result::progress)
		{
			result.code = block_a.valid_predecessor (*previous) ? nano::process_result::progress : nano::process_result::block_position;
			if (result.code == nano::process_result::progress)
			{
				auto account (ledger.store.frontier_get (transaction, block_a.hashables.previous));
				result.code = account.is_zero () ? nano::process_result::fork : nano::process_result::progress;
				if (result.code == nano::process_result::progress)
				{
					// Validate block if not verified outside of ledger
					if (result.verified != nano::signature_verification::valid)
					{
						result.code = validate_message (account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is this block signed correctly (Malformed)
					}
					if (result.code == nano::process_result::progress)
					{
						nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */);
						result.code = block_a.difficulty () >= nano::work_threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed)
						if (result.code == nano::process_result::progress)
						{
							debug_assert (!validate_message (account, hash, block_a.signature));
							result.verified = nano::signature_verification::valid;
							nano::account_info info;
							auto latest_error (ledger.store.account_get (transaction, account, info));
							(void)latest_error;
							debug_assert (!latest_error);
							debug_assert (info.head == block_a.hashables.previous);
							result.code = info.balance.number () >= block_a.hashables.balance.number () ? nano::process_result::progress : nano::process_result::negative_spend; // Is this trying to spend a negative amount (Malicious)
							if (result.code == nano::process_result::progress)
							{
								auto amount (info.balance.number () - block_a.hashables.balance.number ());
								ledger.cache.rep_weights.representation_add (info.representative, 0 - amount);
								block_a.sideband_set (nano::block_sideband (account, 0, block_a.hashables.balance /* unused */, info.block_count + 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */));
								ledger.store.block_put (transaction, hash, block_a);
								nano::account_info new_info (hash, info.representative, info.open_block, block_a.hashables.balance, nano::seconds_since_epoch (), info.block_count + 1, nano::epoch::epoch_0);
								ledger.update_account (transaction, account, info, new_info);
								ledger.store.pending_put (transaction, nano::pending_key (block_a.hashables.destination, hash), { account, amount, nano::epoch::epoch_0 });
								ledger.store.frontier_del (transaction, block_a.hashables.previous);
								ledger.store.frontier_put (transaction, hash, account);
								result.previous_balance = info.balance;
								ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::send);
							}
						}
					}
				}
			}
		}
	}
}

void ledger_processor::receive_block (nano::receive_block & block_a)
{
	auto hash (block_a.hash ());
	auto existing (ledger.block_or_pruned_exists (transaction, hash));
	result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block already?  (Harmless)
	if (result.code == nano::process_result::progress)
	{
		auto previous (ledger.store.block_get (transaction, block_a.hashables.previous));
		result.code = previous != nullptr ? nano::process_result::progress : nano::process_result::gap_previous;
		if (result.code == nano::process_result::progress)
		{
			result.code = block_a.valid_predecessor (*previous) ? nano::process_result::progress : nano::process_result::block_position;
			if (result.code == nano::process_result::progress)
			{
				auto account (ledger.store.frontier_get (transaction, block_a.hashables.previous));
				result.code = account.is_zero () ? nano::process_result::gap_previous : nano::process_result::progress; //Have we seen the previous block? No entries for account at all (Harmless)
				if (result.code == nano::process_result::progress)
				{
					// Validate block if not verified outside of ledger
					if (result.verified != nano::signature_verification::valid)
					{
						result.code = validate_message (account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is the signature valid (Malformed)
					}
					if (result.code == nano::process_result::progress)
					{
						debug_assert (!validate_message (account, hash, block_a.signature));
						result.verified = nano::signature_verification::valid;
						result.code = ledger.block_or_pruned_exists (transaction, block_a.hashables.source) ? nano::process_result::progress : nano::process_result::gap_source; // Have we seen the source block already? (Harmless)
						if (result.code == nano::process_result::progress)
						{
							nano::account_info info;
							ledger.store.account_get (transaction, account, info);
							result.code = info.head == block_a.hashables.previous ? nano::process_result::progress : nano::process_result::gap_previous; // Block doesn't immediately follow latest block (Harmless)
							if (result.code == nano::process_result::progress)
							{
								nano::pending_key key (account, block_a.hashables.source);
								nano::pending_info pending;
								result.code = ledger.store.pending_get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed)
								if (result.code == nano::process_result::progress)
								{
									result.code = pending.epoch == nano::epoch::epoch_0 ? nano::process_result::progress : nano::process_result::unreceivable; // Are we receiving a state-only send? (Malformed)
									if (result.code == nano::process_result::progress)
									{
										nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */);
										result.code = block_a.difficulty () >= nano::work_threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed)
										if (result.code == nano::process_result::progress)
										{
											auto new_balance (info.balance.number () + pending.amount.number ());
#ifdef NDEBUG
											if (ledger.store.block_exists (transaction, block_a.hashables.source))
											{
												nano::account_info source_info;
												[[maybe_unused]] auto error (ledger.store.account_get (transaction, pending.source, source_info));
												debug_assert (!error);
											}
#endif
											ledger.store.pending_del (transaction, key);
											block_a.sideband_set (nano::block_sideband (account, 0, new_balance, info.block_count + 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */));
											ledger.store.block_put (transaction, hash, block_a);
											nano::account_info new_info (hash, info.representative, info.open_block, new_balance, nano::seconds_since_epoch (), info.block_count + 1, nano::epoch::epoch_0);
											ledger.update_account (transaction, account, info, new_info);
											ledger.cache.rep_weights.representation_add (info.representative, pending.amount.number ());
											ledger.store.frontier_del (transaction, block_a.hashables.previous);
											ledger.store.frontier_put (transaction, hash, account);
											result.previous_balance = info.balance;
											ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::receive);
										}
									}
								}
							}
						}
					}
				}
				else
				{
					result.code = ledger.store.block_exists (transaction, block_a.hashables.previous) ? nano::process_result::fork : nano::process_result::gap_previous; // If we have the block but it's not the latest we have a signed fork (Malicious)
				}
			}
		}
	}
}

void ledger_processor::open_block (nano::open_block & block_a)
{
	auto hash (block_a.hash ());
	auto existing (ledger.block_or_pruned_exists (transaction, hash));
	result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block already? (Harmless)
	if (result.code == nano::process_result::progress)
	{
		// Validate block if not verified outside of ledger
		if (result.verified != nano::signature_verification::valid)
		{
			result.code = validate_message (block_a.hashables.account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is the signature valid (Malformed)
		}
		if (result.code == nano::process_result::progress)
		{
			debug_assert (!validate_message (block_a.hashables.account, hash, block_a.signature));
			result.verified = nano::signature_verification::valid;
			result.code = ledger.block_or_pruned_exists (transaction, block_a.hashables.source) ? nano::process_result::progress : nano::process_result::gap_source; // Have we seen the source block? (Harmless)
			if (result.code == nano::process_result::progress)
			{
				nano::account_info info;
				result.code = ledger.store.account_get (transaction, block_a.hashables.account, info) ? nano::process_result::progress : nano::process_result::fork; // Has this account already been opened? (Malicious)
				if (result.code == nano::process_result::progress)
				{
					nano::pending_key key (block_a.hashables.account, block_a.hashables.source);
					nano::pending_info pending;
					result.code = ledger.store.pending_get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed)
					if (result.code == nano::process_result::progress)
					{
						result.code = block_a.hashables.account == ledger.network_params.ledger.burn_account ? nano::process_result::opened_burn_account : nano::process_result::progress; // Is it burning 0 account? (Malicious)
						if (result.code == nano::process_result::progress)
						{
							result.code = pending.epoch == nano::epoch::epoch_0 ? nano::process_result::progress : nano::process_result::unreceivable; // Are we receiving a state-only send? (Malformed)
							if (result.code == nano::process_result::progress)
							{
								nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */);
								result.code = block_a.difficulty () >= nano::work_threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed)
								if (result.code == nano::process_result::progress)
								{
#ifdef NDEBUG
									if (ledger.store.block_exists (transaction, block_a.hashables.source))
									{
										nano::account_info source_info;
										[[maybe_unused]] auto error (ledger.store.account_get (transaction, pending.source, source_info));
										debug_assert (!error);
									}
#endif
									ledger.store.pending_del (transaction, key);
									block_a.sideband_set (nano::block_sideband (block_a.hashables.account, 0, pending.amount, 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */));
									ledger.store.block_put (transaction, hash, block_a);
									nano::account_info new_info (hash, block_a.representative (), hash, pending.amount.number (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0);
									ledger.update_account (transaction, block_a.hashables.account, info, new_info);
									ledger.cache.rep_weights.representation_add (block_a.representative (), pending.amount.number ());
									ledger.store.frontier_put (transaction, hash, block_a.hashables.account);
									result.previous_balance = 0;
									ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::open);
								}
							}
						}
					}
				}
			}
		}
	}
}

ledger_processor::ledger_processor (nano::ledger & ledger_a, nano::write_transaction const & transaction_a, nano::signature_verification verification_a) :
ledger (ledger_a),
transaction (transaction_a),
verification (verification_a)
{
	result.verified = verification;
}
} // namespace

nano::ledger::ledger (nano::block_store & store_a, nano::stat & stat_a, nano::generate_cache const & generate_cache_a) :
store (store_a),
stats (stat_a),
check_bootstrap_weights (true)
{
	if (!store.init_error ())
	{
		initialize (generate_cache_a);
	}
}

void nano::ledger::initialize (nano::generate_cache const & generate_cache_a)
{
	if (generate_cache_a.reps || generate_cache_a.account_count || generate_cache_a.block_count)
	{
		store.accounts_for_each_par (
		[this](nano::read_transaction const & /*unused*/, nano::store_iterator<nano::account, nano::account_info> i, nano::store_iterator<nano::account, nano::account_info> n) {
			uint64_t block_count_l{ 0 };
			uint64_t account_count_l{ 0 };
			decltype (this->cache.rep_weights) rep_weights_l;
			for (; i != n; ++i)
			{
				nano::account_info const & info (i->second);
				block_count_l += info.block_count;
				++account_count_l;
				rep_weights_l.representation_add (info.representative, info.balance.number ());
			}
			this->cache.block_count += block_count_l;
			this->cache.account_count += account_count_l;
			this->cache.rep_weights.copy_from (rep_weights_l);
		});
	}

	if (generate_cache_a.cemented_count)
	{
		store.confirmation_height_for_each_par (
		[this](nano::read_transaction const & /*unused*/, nano::store_iterator<nano::account, nano::confirmation_height_info> i, nano::store_iterator<nano::account, nano::confirmation_height_info> n) {
			uint64_t cemented_count_l (0);
			for (; i != n; ++i)
			{
				cemented_count_l += i->second.height;
			}
			this->cache.cemented_count += cemented_count_l;
		});
	}

	auto transaction (store.tx_begin_read ());
	cache.pruned_count = store.pruned_count (transaction);
}

// Balance for account containing hash
nano::uint128_t nano::ledger::balance (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const
{
	return hash_a.is_zero () ? 0 : store.block_balance (transaction_a, hash_a);
}

nano::uint128_t nano::ledger::balance_safe (nano::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const
{
	nano::uint128_t result (0);
	if (pruning && !hash_a.is_zero () && !store.block_exists (transaction_a, hash_a))
	{
		error_a = true;
		result = 0;
	}
	else
	{
		result = balance (transaction_a, hash_a);
	}
	return result;
}

// Balance for an account by account number
nano::uint128_t nano::ledger::account_balance (nano::transaction const & transaction_a, nano::account const & account_a, bool only_confirmed_a)
{
	nano::uint128_t result (0);
	if (only_confirmed_a)
	{
		nano::confirmation_height_info info;
		if (!store.confirmation_height_get (transaction_a, account_a, info))
		{
			result = balance (transaction_a, info.frontier);
		}
	}
	else
	{
		nano::account_info info;
		auto none (store.account_get (transaction_a, account_a, info));
		if (!none)
		{
			result = info.balance.number ();
		}
	}
	return result;
}

nano::uint128_t nano::ledger::account_pending (nano::transaction const & transaction_a, nano::account const & account_a, bool only_confirmed_a)
{
	nano::uint128_t result (0);
	nano::account end (account_a.number () + 1);
	for (auto i (store.pending_begin (transaction_a, nano::pending_key (account_a, 0))), n (store.pending_begin (transaction_a, nano::pending_key (end, 0))); i != n; ++i)
	{
		nano::pending_info const & info (i->second);
		if (only_confirmed_a)
		{
			if (block_confirmed (transaction_a, i->first.hash) || (pruning && store.pruned_exists (transaction_a, i->first.hash)))
			{
				result += info.amount.number ();
			}
		}
		else
		{
			result += info.amount.number ();
		}
	}
	return result;
}

nano::process_return nano::ledger::process (nano::write_transaction const & transaction_a, nano::block & block_a, nano::signature_verification verification)
{
	debug_assert (!nano::work_validate_entry (block_a) || network_params.network.is_dev_network ());
	ledger_processor processor (*this, transaction_a, verification);
	block_a.visit (processor);
	if (processor.result.code == nano::process_result::progress)
	{
		++cache.block_count;
	}
	return processor.result;
}

nano::block_hash nano::ledger::representative (nano::transaction const & transaction_a, nano::block_hash const & hash_a)
{
	auto result (representative_calculated (transaction_a, hash_a));
	debug_assert (result.is_zero () || store.block_exists (transaction_a, result));
	return result;
}

nano::block_hash nano::ledger::representative_calculated (nano::transaction const & transaction_a, nano::block_hash const & hash_a)
{
	representative_visitor visitor (transaction_a, store);
	visitor.compute (hash_a);
	return visitor.result;
}

bool nano::ledger::block_exists (nano::block_hash const & hash_a) const
{
	return store.block_exists (store.tx_begin_read (), hash_a);
}

bool nano::ledger::block_or_pruned_exists (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const
{
	return pruning ? store.block_or_pruned_exists (transaction_a, hash_a) : store.block_exists (transaction_a, hash_a);
}

bool nano::ledger::block_or_pruned_exists (nano::block_hash const & hash_a) const
{
	return block_or_pruned_exists (store.tx_begin_read (), hash_a);
}

std::string nano::ledger::block_text (char const * hash_a)
{
	return block_text (nano::block_hash (hash_a));
}

std::string nano::ledger::block_text (nano::block_hash const & hash_a)
{
	std::string result;
	auto transaction (store.tx_begin_read ());
	auto block (store.block_get (transaction, hash_a));
	if (block != nullptr)
	{
		block->serialize_json (result);
	}
	return result;
}

bool nano::ledger::is_send (nano::transaction const & transaction_a, nano::state_block const & block_a) const
{
	/*
	 * if block_a does not have a sideband, then is_send()
	 * requires that the previous block exists in the database.
	 * This is because it must retrieve the balance of the previous block.
	 */
	debug_assert (block_a.has_sideband () || block_a.hashables.previous.is_zero () || store.block_exists (transaction_a, block_a.hashables.previous));

	bool result (false);
	if (block_a.has_sideband ())
	{
		result = block_a.sideband ().details.is_send;
	}
	else
	{
		nano::block_hash previous (block_a.hashables.previous);
		if (!previous.is_zero ())
		{
			if (block_a.hashables.balance < balance (transaction_a, previous))
			{
				result = true;
			}
		}
	}
	return result;
}

nano::account const & nano::ledger::block_destination (nano::transaction const & transaction_a, nano::block const & block_a)
{
	nano::send_block const * send_block (dynamic_cast<nano::send_block const *> (&block_a));
	nano::state_block const * state_block (dynamic_cast<nano::state_block const *> (&block_a));
	if (send_block != nullptr)
	{
		return send_block->hashables.destination;
	}
	else if (state_block != nullptr && is_send (transaction_a, *state_block))
	{
		return state_block->hashables.link.as_account ();
	}
	static nano::account result (0);
	return result;
}

nano::block_hash nano::ledger::block_source (nano::transaction const & transaction_a, nano::block const & block_a)
{
	/*
	 * block_source() requires that the previous block of the block
	 * passed in exist in the database.  This is because it will try
	 * to check account balances to determine if it is a send block.
	 */
	debug_assert (block_a.previous ().is_zero () || store.block_exists (transaction_a, block_a.previous ()));

	// If block_a.source () is nonzero, then we have our source.
	// However, universal blocks will always return zero.
	nano::block_hash result (block_a.source ());
	nano::state_block const * state_block (dynamic_cast<nano::state_block const *> (&block_a));
	if (state_block != nullptr && !is_send (transaction_a, *state_block))
	{
		result = state_block->hashables.link.as_block_hash ();
	}
	return result;
}

std::pair<nano::block_hash, nano::block_hash> nano::ledger::hash_root_random (nano::transaction const & transaction_a) const
{
	nano::block_hash hash (0);
	nano::root root (0);
	if (!pruning)
	{
		auto block (store.block_random (transaction_a));
		hash = block->hash ();
		root = block->root ();
	}
	else
	{
		uint64_t count (cache.block_count);
		release_assert (std::numeric_limits<CryptoPP::word32>::max () > count);
		auto region = static_cast<size_t> (nano::random_pool::generate_word32 (0, static_cast<CryptoPP::word32> (count - 1)));
		// Pruned cache cannot guarantee that pruned blocks are already commited
		if (region < cache.pruned_count)
		{
			hash = store.pruned_random (transaction_a);
		}
		if (hash.is_zero ())
		{
			auto block (store.block_random (transaction_a));
			hash = block->hash ();
			root = block->root ();
		}
	}
	return std::make_pair (hash, root.as_block_hash ());
}

// Vote weight of an account
nano::uint128_t nano::ledger::weight (nano::account const & account_a)
{
	if (check_bootstrap_weights.load ())
	{
		if (cache.block_count < bootstrap_weight_max_blocks)
		{
			auto weight = bootstrap_weights.find (account_a);
			if (weight != bootstrap_weights.end ())
			{
				return weight->second;
			}
		}
		else
		{
			check_bootstrap_weights = false;
		}
	}
	return cache.rep_weights.representation_get (account_a);
}

// Rollback blocks until `block_a' doesn't exist or it tries to penetrate the confirmation height
bool nano::ledger::rollback (nano::write_transaction const & transaction_a, nano::block_hash const & block_a, std::vector<std::shared_ptr<nano::block>> & list_a)
{
	debug_assert (store.block_exists (transaction_a, block_a));
	auto account_l (account (transaction_a, block_a));
	auto block_account_height (store.block_account_height (transaction_a, block_a));
	rollback_visitor rollback (transaction_a, *this, list_a);
	nano::account_info account_info;
	auto error (false);
	while (!error && store.block_exists (transaction_a, block_a))
	{
		nano::confirmation_height_info confirmation_height_info;
		store.confirmation_height_get (transaction_a, account_l, confirmation_height_info);
		if (block_account_height > confirmation_height_info.height)
		{
			auto latest_error = store.account_get (transaction_a, account_l, account_info);
			debug_assert (!latest_error);
			auto block (store.block_get (transaction_a, account_info.head));
			list_a.push_back (block);
			block->visit (rollback);
			error = rollback.error;
			if (!error)
			{
				--cache.block_count;
			}
		}
		else
		{
			error = true;
		}
	}
	return error;
}

bool nano::ledger::rollback (nano::write_transaction const & transaction_a, nano::block_hash const & block_a)
{
	std::vector<std::shared_ptr<nano::block>> rollback_list;
	return rollback (transaction_a, block_a, rollback_list);
}

// Return account containing hash
nano::account nano::ledger::account (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const
{
	return store.block_account (transaction_a, hash_a);
}

nano::account nano::ledger::account_safe (nano::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const
{
	if (!pruning)
	{
		return store.block_account (transaction_a, hash_a);
	}
	else
	{
		auto block (store.block_get (transaction_a, hash_a));
		if (block != nullptr)
		{
			return store.block_account_calculated (*block);
		}
		else
		{
			error_a = true;
			return 0;
		}
	}
}

// Return amount decrease or increase for block
nano::uint128_t nano::ledger::amount (nano::transaction const & transaction_a, nano::account const & account_a)
{
	release_assert (account_a == network_params.ledger.genesis_account);
	return network_params.ledger.genesis_amount;
}

nano::uint128_t nano::ledger::amount (nano::transaction const & transaction_a, nano::block_hash const & hash_a)
{
	auto block (store.block_get (transaction_a, hash_a));
	auto block_balance (balance (transaction_a, hash_a));
	auto previous_balance (balance (transaction_a, block->previous ()));
	return block_balance > previous_balance ? block_balance - previous_balance : previous_balance - block_balance;
}

nano::uint128_t nano::ledger::amount_safe (nano::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const
{
	auto block (store.block_get (transaction_a, hash_a));
	debug_assert (block);
	auto block_balance (balance (transaction_a, hash_a));
	auto previous_balance (balance_safe (transaction_a, block->previous (), error_a));
	return error_a ? 0 : block_balance > previous_balance ? block_balance - previous_balance : previous_balance - block_balance;
}

// Return latest block for account
nano::block_hash nano::ledger::latest (nano::transaction const & transaction_a, nano::account const & account_a)
{
	nano::account_info info;
	auto latest_error (store.account_get (transaction_a, account_a, info));
	return latest_error ? 0 : info.head;
}

// Return latest root for account, account number if there are no blocks for this account.
nano::root nano::ledger::latest_root (nano::transaction const & transaction_a, nano::account const & account_a)
{
	nano::account_info info;
	if (store.account_get (transaction_a, account_a, info))
	{
		return account_a;
	}
	else
	{
		return info.head;
	}
}

void nano::ledger::dump_account_chain (nano::account const & account_a, std::ostream & stream)
{
	auto transaction (store.tx_begin_read ());
	auto hash (latest (transaction, account_a));
	while (!hash.is_zero ())
	{
		auto block (store.block_get (transaction, hash));
		debug_assert (block != nullptr);
		stream << hash.to_string () << std::endl;
		hash = block->previous ();
	}
}

bool nano::ledger::could_fit (nano::transaction const & transaction_a, nano::block const & block_a) const
{
	auto dependencies (dependent_blocks (transaction_a, block_a));
	return std::all_of (dependencies.begin (), dependencies.end (), [this, &transaction_a](nano::block_hash const & hash_a) {
		return hash_a.is_zero () || store.block_exists (transaction_a, hash_a);
	});
}

bool nano::ledger::dependents_confirmed (nano::transaction const & transaction_a, nano::block const & block_a) const
{
	auto dependencies (dependent_blocks (transaction_a, block_a));
	return std::all_of (dependencies.begin (), dependencies.end (), [this, &transaction_a](nano::block_hash const & hash_a) {
		auto result (hash_a.is_zero ());
		if (!result)
		{
			result = block_confirmed (transaction_a, hash_a);
		}
		return result;
	});
}

bool nano::ledger::is_epoch_link (nano::link const & link_a) const
{
	return network_params.ledger.epochs.is_epoch_link (link_a);
}

class dependent_block_visitor : public nano::block_visitor
{
public:
	dependent_block_visitor (nano::ledger const & ledger_a, nano::transaction const & transaction_a) :
	ledger (ledger_a),
	transaction (transaction_a),
	result ({ 0, 0 })
	{
	}
	void send_block (nano::send_block const & block_a) override
	{
		result[0] = block_a.previous ();
	}
	void receive_block (nano::receive_block const & block_a) override
	{
		result[0] = block_a.previous ();
		result[1] = block_a.source ();
	}
	void open_block (nano::open_block const & block_a) override
	{
		if (block_a.source () != ledger.network_params.ledger.genesis_account)
		{
			result[0] = block_a.source ();
		}
	}
	void change_block (nano::change_block const & block_a) override
	{
		result[0] = block_a.previous ();
	}
	void state_block (nano::state_block const & block_a) override
	{
		result[0] = block_a.hashables.previous;
		result[1] = block_a.hashables.link.as_block_hash ();
		// ledger.is_send will check the sideband first, if block_a has a loaded sideband the check that previous block exists can be skipped
		if (ledger.is_epoch_link (block_a.hashables.link) || ((block_a.has_sideband () || ledger.store.block_exists (transaction, block_a.hashables.previous)) && ledger.is_send (transaction, block_a)))
		{
			result[1].clear ();
		}
	}
	nano::ledger const & ledger;
	nano::transaction const & transaction;
	std::array<nano::block_hash, 2> result;
};

std::array<nano::block_hash, 2> nano::ledger::dependent_blocks (nano::transaction const & transaction_a, nano::block const & block_a) const
{
	dependent_block_visitor visitor (*this, transaction_a);
	block_a.visit (visitor);
	return visitor.result;
}

nano::account const & nano::ledger::epoch_signer (nano::link const & link_a) const
{
	return network_params.ledger.epochs.signer (network_params.ledger.epochs.epoch (link_a));
}

nano::link const & nano::ledger::epoch_link (nano::epoch epoch_a) const
{
	return network_params.ledger.epochs.link (epoch_a);
}

void nano::ledger::update_account (nano::write_transaction const & transaction_a, nano::account const & account_a, nano::account_info const & old_a, nano::account_info const & new_a)
{
	if (!new_a.head.is_zero ())
	{
		if (old_a.head.is_zero () && new_a.open_block == new_a.head)
		{
			++cache.account_count;
		}
		if (!old_a.head.is_zero () && old_a.epoch () != new_a.epoch ())
		{
			// store.account_put won't erase existing entries if they're in different tables
			store.account_del (transaction_a, account_a);
		}
		store.account_put (transaction_a, account_a, new_a);
	}
	else
	{
		debug_assert (!store.confirmation_height_exists (transaction_a, account_a));
		store.account_del (transaction_a, account_a);
		debug_assert (cache.account_count > 0);
		--cache.account_count;
	}
}

std::shared_ptr<nano::block> nano::ledger::successor (nano::transaction const & transaction_a, nano::qualified_root const & root_a)
{
	nano::block_hash successor (0);
	auto get_from_previous = false;
	if (root_a.previous ().is_zero ())
	{
		nano::account_info info;
		if (!store.account_get (transaction_a, root_a.root ().as_account (), info))
		{
			successor = info.open_block;
		}
		else
		{
			get_from_previous = true;
		}
	}
	else
	{
		get_from_previous = true;
	}

	if (get_from_previous)
	{
		successor = store.block_successor (transaction_a, root_a.previous ());
	}
	std::shared_ptr<nano::block> result;
	if (!successor.is_zero ())
	{
		result = store.block_get (transaction_a, successor);
	}
	debug_assert (successor.is_zero () || result != nullptr);
	return result;
}

std::shared_ptr<nano::block> nano::ledger::forked_block (nano::transaction const & transaction_a, nano::block const & block_a)
{
	debug_assert (!store.block_exists (transaction_a, block_a.hash ()));
	auto root (block_a.root ());
	debug_assert (store.block_exists (transaction_a, root.as_block_hash ()) || store.account_exists (transaction_a, root.as_account ()));
	auto result (store.block_get (transaction_a, store.block_successor (transaction_a, root.as_block_hash ())));
	if (result == nullptr)
	{
		nano::account_info info;
		auto error (store.account_get (transaction_a, root.as_account (), info));
		(void)error;
		debug_assert (!error);
		result = store.block_get (transaction_a, info.open_block);
		debug_assert (result != nullptr);
	}
	return result;
}

bool nano::ledger::block_confirmed (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const
{
	auto confirmed (false);
	auto block = store.block_get (transaction_a, hash_a);
	if (block)
	{
		nano::confirmation_height_info confirmation_height_info;
		store.confirmation_height_get (transaction_a, block->account ().is_zero () ? block->sideband ().account : block->account (), confirmation_height_info);
		confirmed = (confirmation_height_info.height >= block->sideband ().height);
	}
	return confirmed;
}

uint64_t nano::ledger::pruning_action (nano::write_transaction & transaction_a, nano::block_hash const & hash_a, uint64_t const batch_size_a)
{
	uint64_t pruned_count (0);
	nano::block_hash hash (hash_a);
	while (!hash.is_zero () && hash != network_params.ledger.genesis_hash)
	{
		auto block (store.block_get (transaction_a, hash));
		if (block != nullptr)
		{
			store.block_del (transaction_a, hash);
			store.pruned_put (transaction_a, hash);
			hash = block->previous ();
			++pruned_count;
			++cache.pruned_count;
			if (pruned_count % batch_size_a == 0)
			{
				transaction_a.commit ();
				transaction_a.renew ();
			}
		}
		else if (store.pruned_exists (transaction_a, hash))
		{
			hash = 0;
		}
		else
		{
			hash = 0;
			release_assert (false && ""Error finding block for pruning"");
		}
	}
	return pruned_count;
}

std::multimap<uint64_t, nano::uncemented_info, std::greater<>> nano::ledger::unconfirmed_frontiers () const
{
	nano::locked<std::multimap<uint64_t, nano::uncemented_info, std::greater<>>> result;
	using result_t = decltype (result)::value_type;

	store.accounts_for_each_par ([this, &result](nano::read_transaction const & transaction_a, nano::store_iterator<nano::account, nano::account_info> i, nano::store_iterator<nano::account, nano::account_info> n) {
		result_t unconfirmed_frontiers_l;
		for (; i != n; ++i)
		{
			auto const & account (i->first);
			auto const & account_info (i->second);

			nano::confirmation_height_info conf_height_info;
			this->store.confirmation_height_get (transaction_a, account, conf_height_info);

			if (account_info.block_count != conf_height_info.height)
			{
				// Always output as no confirmation height has been set on the account yet
				auto height_delta = account_info.block_count - conf_height_info.height;
				auto const & frontier = account_info.head;
				auto const & cemented_frontier = conf_height_info.frontier;
				unconfirmed_frontiers_l.emplace (std::piecewise_construct, std::forward_as_tuple (height_delta), std::forward_as_tuple (cemented_frontier, frontier, i->first));
			}
		}
		// Merge results
		auto result_locked = result.lock ();
		result_locked->insert (unconfirmed_frontiers_l.begin (), unconfirmed_frontiers_l.end ());
	});
	return result;
}

// A precondition is that the store is an LMDB store
bool nano::ledger::migrate_lmdb_to_rocksdb (boost::filesystem::path const & data_path_a) const
{
	boost::system::error_code error_chmod;
	nano::set_secure_perm_directory (data_path_a, error_chmod);
	auto rockdb_data_path = data_path_a / ""rocksdb"";
	boost::filesystem::remove_all (rockdb_data_path);

	nano::logger_mt logger;
	auto error (false);

	// Open rocksdb database
	nano::rocksdb_config rocksdb_config;
	rocksdb_config.enable = true;
	auto rocksdb_store = nano::make_store (logger, data_path_a, false, true, rocksdb_config);

	if (!rocksdb_store->init_error ())
	{
		store.blocks_for_each_par (
		[&rocksdb_store](nano::read_transaction const & /*unused*/, auto i, auto n) {
			for (; i != n; ++i)
			{
				auto rocksdb_transaction (rocksdb_store->tx_begin_write ({}, { nano::tables::blocks }));

				std::vector<uint8_t> vector;
				{
					nano::vectorstream stream (vector);
					nano::serialize_block (stream, *i->second.block);
					i->second.sideband.serialize (stream, i->second.block->type ());
				}
				rocksdb_store->block_raw_put (rocksdb_transaction, vector, i->first);
			}
		});

		store.unchecked_for_each_par (
		[&rocksdb_store](nano::read_transaction const & /*unused*/, auto i, auto n) {
			for (; i != n; ++i)
			{
				auto rocksdb_transaction (rocksdb_store->tx_begin_write ({}, { nano::tables::unchecked }));
				rocksdb_store->unchecked_put (rocksdb_transaction, i->first, i->second);
			}
		});

		store.pending_for_each_par (
		[&rocksdb_store](nano::read_transaction const & /*unused*/, auto i, auto n) {
			for (; i != n; ++i)
			{
				auto rocksdb_transaction (rocksdb_store->tx_begin_write ({}, { nano::tables::pending }));
				rocksdb_store->pending_put (rocksdb_transaction, i->first, i->second);
			}
		});

		store.confirmation_height_for_each_par (
		[&rocksdb_store](nano::read_transaction const & /*unused*/, auto i, auto n) {
			for (; i != n; ++i)
			{
				auto rocksdb_transaction (rocksdb_store->tx_begin_write ({}, { nano::tables::confirmation_height }));
				rocksdb_store->confirmation_height_put (rocksdb_transaction, i->first, i->second);
			}
		});

		store.accounts_for_each_par (
		[&rocksdb_store](nano::read_transaction const & /*unused*/, auto i, auto n) {
			for (; i != n; ++i)
			{
				auto rocksdb_transaction (rocksdb_store->tx_begin_write ({}, { nano::tables::accounts }));
				rocksdb_store->account_put (rocksdb_transaction, i->first, i->second);
			}
		});

		store.frontiers_for_each_par (
		[&rocksdb_store](nano::read_transaction const & /*unused*/, auto i, auto n) {
			for (; i != n; ++i)
			{
				auto rocksdb_transaction (rocksdb_store->tx_begin_write ({}, { nano::tables::frontiers }));
				rocksdb_store->frontier_put (rocksdb_transaction, i->first, i->second);
			}
		});

		store.pruned_for_each_par (
		[&rocksdb_store](nano::read_transaction const & /*unused*/, auto i, auto n) {
			for (; i != n; ++i)
			{
				auto rocksdb_transaction (rocksdb_store->tx_begin_write ({}, { nano::tables::pruned }));
				rocksdb_store->pruned_put (rocksdb_transaction, i->first);
			}
		});

		auto lmdb_transaction (store.tx_begin_read ());
		auto version = store.version_get (lmdb_transaction);
		auto rocksdb_transaction (rocksdb_store->tx_begin_write ());
		rocksdb_store->version_put (rocksdb_transaction, version);

		for (auto i (store.online_weight_begin (lmdb_transaction)), n (store.online_weight_end ()); i != n; ++i)
		{
			rocksdb_store->online_weight_put (rocksdb_transaction, i->first, i->second);
		}

		for (auto i (store.peers_begin (lmdb_transaction)), n (store.peers_end ()); i != n; ++i)
		{
			rocksdb_store->peer_put (rocksdb_transaction, i->first);
		}

		// Compare counts
		error |= store.unchecked_count (lmdb_transaction) != rocksdb_store->unchecked_count (rocksdb_transaction);
		error |= store.peer_count (lmdb_transaction) != rocksdb_store->peer_count (rocksdb_transaction);
		error |= store.pruned_count (lmdb_transaction) != rocksdb_store->pruned_count (rocksdb_transaction);
		error |= store.online_weight_count (lmdb_transaction) != rocksdb_store->online_weight_count (rocksdb_transaction);
		error |= store.version_get (lmdb_transaction) != rocksdb_store->version_get (rocksdb_transaction);

		// For large tables a random key is used instead and makes sure it exists
		auto random_block (store.block_random (lmdb_transaction));
		error |= rocksdb_store->block_get (rocksdb_transaction, random_block->hash ()) == nullptr;

		auto account = random_block->account ().is_zero () ? random_block->sideband ().account : random_block->account ();
		nano::account_info account_info;
		error |= rocksdb_store->account_get (rocksdb_transaction, account, account_info);

		// If confirmation height exists in the lmdb ledger for this account it should exist in the rocksdb ledger
		nano::confirmation_height_info confirmation_height_info;
		if (!store.confirmation_height_get (lmdb_transaction, account, confirmation_height_info))
		{
			error |= rocksdb_store->confirmation_height_get (rocksdb_transaction, account, confirmation_height_info);
		}
	}
	else
	{
		error = true;
	}
	return error;
}

nano::uncemented_info::uncemented_info (nano::block_hash const & cemented_frontier, nano::block_hash const & frontier, nano::account const & account) :
cemented_frontier (cemented_frontier), frontier (frontier), account (account)
{
}

std::unique_ptr<nano::container_info_component> nano::collect_container_info (ledger & ledger, const std::string & name)
{
	auto count = ledger.bootstrap_weights_size.load ();
	auto sizeof_element = sizeof (decltype (ledger.bootstrap_weights)::value_type);
	auto composite = std::make_unique<container_info_composite> (name);
	composite->add_component (std::make_unique<container_info_leaf> (container_info{ ""bootstrap_weights"", count, sizeof_element }));
	composite->add_component (collect_container_info (ledger.cache.rep_weights, ""rep_weights""));
	return composite;
}
",16321,True,2954.219683193742,median
"#include ""NativeEngine.h""
#include ""ShaderCompiler.h""
#include <arcana/threading/task.h>
#include <arcana/threading/task_schedulers.h>

#include <napi/env.h>

#include <bgfx/bgfx.h>

#include <bimg/bimg.h>
#include <bimg/decode.h>
#include <bimg/encode.h>

#include <bx/math.h>

#include <queue>
#include <regex>
#include <sstream>
#include <variant>

namespace Babylon
{
    namespace
    {
        namespace TextureSampling
        {
            constexpr uint32_t BGFX_SAMPLER_DEFAULT = 0;

            // clang-format off
            // Names, as in constants.ts are MAG_MIN(_MIP?)     MAG                         MIN                         MIP
            constexpr uint32_t NEAREST_NEAREST =                BGFX_SAMPLER_MAG_POINT  |   BGFX_SAMPLER_MIN_POINT  |   BGFX_SAMPLER_DEFAULT    ;
            constexpr uint32_t LINEAR_LINEAR =                  BGFX_SAMPLER_DEFAULT    |   BGFX_SAMPLER_DEFAULT    |   BGFX_SAMPLER_DEFAULT    ;
            constexpr uint32_t LINEAR_LINEAR_MIPLINEAR =        BGFX_SAMPLER_DEFAULT    |   BGFX_SAMPLER_DEFAULT    |   BGFX_SAMPLER_DEFAULT    ;
            constexpr uint32_t NEAREST_NEAREST_MIPNEAREST =     BGFX_SAMPLER_MAG_POINT  |   BGFX_SAMPLER_MIN_POINT  |   BGFX_SAMPLER_MIP_POINT  ;
            constexpr uint32_t NEAREST_LINEAR_MIPNEAREST =      BGFX_SAMPLER_MAG_POINT  |   BGFX_SAMPLER_DEFAULT    |   BGFX_SAMPLER_MIP_POINT  ;
            constexpr uint32_t NEAREST_LINEAR_MIPLINEAR =       BGFX_SAMPLER_MAG_POINT  |   BGFX_SAMPLER_DEFAULT    |   BGFX_SAMPLER_DEFAULT    ;
            constexpr uint32_t NEAREST_LINEAR =                 BGFX_SAMPLER_MAG_POINT  |   BGFX_SAMPLER_DEFAULT    |   BGFX_SAMPLER_DEFAULT    ;
            constexpr uint32_t NEAREST_NEAREST_MIPLINEAR =      BGFX_SAMPLER_MAG_POINT  |   BGFX_SAMPLER_MIN_POINT  |   BGFX_SAMPLER_DEFAULT    ;
            constexpr uint32_t LINEAR_NEAREST_MIPNEAREST =      BGFX_SAMPLER_DEFAULT    |   BGFX_SAMPLER_MIN_POINT  |   BGFX_SAMPLER_MIP_POINT  ;
            constexpr uint32_t LINEAR_NEAREST_MIPLINEAR =       BGFX_SAMPLER_DEFAULT    |   BGFX_SAMPLER_MIN_POINT  |   BGFX_SAMPLER_DEFAULT    ;
            constexpr uint32_t LINEAR_LINEAR_MIPNEAREST =       BGFX_SAMPLER_DEFAULT    |   BGFX_SAMPLER_DEFAULT    |   BGFX_SAMPLER_MIP_POINT  ;
            constexpr uint32_t LINEAR_NEAREST =                 BGFX_SAMPLER_DEFAULT    |   BGFX_SAMPLER_MIN_POINT  |   BGFX_SAMPLER_DEFAULT    ;
            // clang-format on
        }

        namespace AlphaMode
        {
            constexpr uint64_t DISABLE = 0x0;
            constexpr uint64_t ADD = BGFX_STATE_BLEND_FUNC_SEPARATE(BGFX_STATE_BLEND_SRC_ALPHA, BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ZERO, BGFX_STATE_BLEND_ONE);
            constexpr uint64_t COMBINE = BGFX_STATE_BLEND_FUNC_SEPARATE(BGFX_STATE_BLEND_SRC_ALPHA, BGFX_STATE_BLEND_INV_SRC_ALPHA, BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ONE);
            constexpr uint64_t SUBTRACT = BGFX_STATE_BLEND_FUNC_SEPARATE(BGFX_STATE_BLEND_ZERO, BGFX_STATE_BLEND_INV_SRC_COLOR, BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ONE);
            constexpr uint64_t MULTIPLY = BGFX_STATE_BLEND_FUNC_SEPARATE(BGFX_STATE_BLEND_DST_COLOR, BGFX_STATE_BLEND_ZERO, BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ONE);
            constexpr uint64_t MAXIMIZED = BGFX_STATE_BLEND_FUNC_SEPARATE(BGFX_STATE_BLEND_SRC_ALPHA, BGFX_STATE_BLEND_INV_SRC_COLOR, BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ONE);
            constexpr uint64_t ONEONE = BGFX_STATE_BLEND_FUNC_SEPARATE(BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ZERO, BGFX_STATE_BLEND_ONE);
            constexpr uint64_t PREMULTIPLIED = BGFX_STATE_BLEND_FUNC_SEPARATE(BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_INV_SRC_ALPHA, BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ONE);
            constexpr uint64_t PREMULTIPLIED_PORTERDUFF = BGFX_STATE_BLEND_FUNC_SEPARATE(BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_INV_SRC_ALPHA, BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_INV_SRC_ALPHA);
            constexpr uint64_t INTERPOLATE = BGFX_STATE_BLEND_FUNC_SEPARATE(BGFX_STATE_BLEND_FACTOR, BGFX_STATE_BLEND_INV_FACTOR, BGFX_STATE_BLEND_FACTOR, BGFX_STATE_BLEND_INV_FACTOR);
            constexpr uint64_t SCREENMODE = BGFX_STATE_BLEND_FUNC_SEPARATE(BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_INV_SRC_COLOR, BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_INV_SRC_ALPHA);
        }

        static_assert(static_cast<bgfx::TextureFormat::Enum>(bimg::TextureFormat::Count) == bgfx::TextureFormat::Count);
        static_assert(static_cast<bgfx::TextureFormat::Enum>(bimg::TextureFormat::RGBA8) == bgfx::TextureFormat::RGBA8);
        static_assert(static_cast<bgfx::TextureFormat::Enum>(bimg::TextureFormat::RGB8) == bgfx::TextureFormat::RGB8);

        bgfx::TextureFormat::Enum Cast(bimg::TextureFormat::Enum format)
        {
            return static_cast<bgfx::TextureFormat::Enum>(format);
        }

        void FlipY(bimg::ImageContainer* image)
        {
            uint8_t* bytes = static_cast<uint8_t*>(image->m_data);
            uint32_t rowCount = image->m_height;
            uint32_t rowPitch = image->m_size / image->m_height;

            std::vector<uint8_t> buffer(rowPitch);

            for (size_t row = 0; row < rowCount / 2; row++)
            {
                auto frontPtr = bytes + (row * rowPitch);
                auto backPtr = bytes + ((rowCount - row - 1) * rowPitch);

                std::memcpy(buffer.data(), frontPtr, rowPitch);
                std::memcpy(frontPtr, backPtr, rowPitch);
                std::memcpy(backPtr, buffer.data(), rowPitch);
            }
        }

        void GenerateMips(bx::AllocatorI* allocator, bimg::ImageContainer** image)
        {
            bimg::ImageContainer* input = *image;

            bimg::ImageContainer* output = bimg::imageGenerateMips(allocator, *input);
            if (output == nullptr)
            {
                bimg::TextureFormat::Enum format = input->m_format;
                bimg::ImageContainer* rgba = bimg::imageConvert(allocator, bimg::TextureFormat::RGBA8, *input, false);
                bimg::imageFree(input);
                bimg::ImageContainer* mips = bimg::imageGenerateMips(allocator, *rgba);
                bimg::imageFree(rgba);
                output = bimg::imageConvert(allocator, format, *mips);
                bimg::imageFree(mips);
            }
            else
            {
                bimg::imageFree(input);
            }

            *image = output;
        }

        void CreateTextureFromImage(TextureData* texture, bimg::ImageContainer* image)
        {
            auto releaseFn = [](void* /*ptr*/, void* userData) {
                bimg::imageFree(static_cast<bimg::ImageContainer*>(userData));
            };

            auto mem = bgfx::makeRef(image->m_data, image->m_size, releaseFn, image);

            texture->Handle = bgfx::createTexture2D(static_cast<uint16_t>(image->m_width), static_cast<uint16_t>(image->m_height), (image->m_numMips > 1), 1, Cast(image->m_format), BGFX_TEXTURE_NONE | BGFX_SAMPLER_NONE, mem);
            texture->Width = image->m_width;
            texture->Height = image->m_height;
        }

        void CreateCubeTextureFromImages(TextureData* texture, const std::vector<bimg::ImageContainer*>& images, bool hasMips)
        {
            const bimg::ImageContainer* firstImage = images.front();
            uint32_t width = firstImage->m_width;
            uint32_t height = firstImage->m_height;
            bgfx::TextureFormat::Enum format = Cast(firstImage->m_format);

            uint32_t totalSize = 0;
            for (auto image : images)
            {
                totalSize += image->m_size;
            }

            // Combine all the faces into one chunk.
            const bgfx::Memory* mem = bgfx::alloc(totalSize);
            uint8_t* ptr = mem->data;
            for (bimg::ImageContainer* image : images)
            {
                std::memcpy(ptr, image->m_data, image->m_size);
                ptr += image->m_size;
                bimg::imageFree(image);
            }

            texture->Handle = bgfx::createTextureCube(static_cast<uint16_t>(width), hasMips, 1, format, BGFX_TEXTURE_NONE | BGFX_SAMPLER_NONE, mem);
            texture->Width = width;
            texture->Height = height;
        }
    }

    template<typename Handle1T, typename Handle2T>
    class VariantHandleHolder
    {
    public:
        std::variant<Handle1T, Handle2T> m_handle{};

        template<typename NonDynamicCallableT, typename DynamicCallableT>
        void DoForHandleTypes(NonDynamicCallableT& nonDynamicCallable, DynamicCallableT& dynamicCallable) const
        {
            if (auto handle = std::get_if<Handle1T>(&m_handle))
            {
                nonDynamicCallable(*handle);
            }
            else
            {
                dynamicCallable(std::get<Handle2T>(m_handle));
            }
        }
    };

    class IndexBufferData final : private VariantHandleHolder<bgfx::IndexBufferHandle, bgfx::DynamicIndexBufferHandle>
    {
    public:
        IndexBufferData(const Napi::TypedArray& bytes, uint16_t flags, bool dynamic)
        {
            const bgfx::Memory* memory = bgfx::copy(bytes.As<Napi::Uint8Array>().Data(), static_cast<uint32_t>(bytes.ByteLength()));
            if (!dynamic)
            {
                m_handle = bgfx::createIndexBuffer(memory, flags);
            }
            else
            {
                m_handle = bgfx::createDynamicIndexBuffer(memory, flags);
            }
        }

        ~IndexBufferData()
        {
            constexpr auto nonDynamic = [](auto handle) {
                bgfx::destroy(handle);
            };
            constexpr auto dynamic = [](auto handle) {
                bgfx::destroy(handle);
            };
            DoForHandleTypes(nonDynamic, dynamic);
        }

        void Update(Napi::Env env, const Napi::TypedArray& bytes, uint32_t startingIdx)
        {
            const bgfx::Memory* memory = bgfx::copy(bytes.As<Napi::Uint8Array>().Data(), static_cast<uint32_t>(bytes.ByteLength()));

            auto nonDynamic = [env](auto) {
                throw Napi::Error::New(env, ""Cannot update a non-dynamic index buffer."");
            };
            const auto dynamic = [memory, startingIdx](auto handle) {
                bgfx::update(handle, startingIdx, memory);
            };
            DoForHandleTypes(nonDynamic, dynamic);
        }

        void SetBgfxIndexBuffer(uint32_t firstIndex, uint32_t numIndices) const
        {
            const auto nonDynamic = [firstIndex, numIndices](auto handle) {
                bgfx::setIndexBuffer(handle, firstIndex, numIndices);
            };
            const auto dynamic = [firstIndex, numIndices](auto handle) {
                bgfx::setIndexBuffer(handle, firstIndex, numIndices);
            };
            DoForHandleTypes(nonDynamic, dynamic);
        }
    };

    class VertexBufferData final : VariantHandleHolder<bgfx::VertexBufferHandle, bgfx::DynamicVertexBufferHandle>
    {
    public:
        VertexBufferData(const Napi::Uint8Array& bytes, bool dynamic)
            : m_bytes{bytes.Data(), bytes.Data() + bytes.ByteLength()}
        {
            if (!dynamic)
            {
                m_handle = bgfx::VertexBufferHandle{bgfx::kInvalidHandle};
            }
            else
            {
                m_handle = bgfx::DynamicVertexBufferHandle{bgfx::kInvalidHandle};
            }
        }

        ~VertexBufferData()
        {
            constexpr auto nonDynamic = [](auto handle) {
                if (handle.idx != bgfx::kInvalidHandle)
                {
                    bgfx::destroy(handle);
                }
            };
            constexpr auto dynamic = [](auto handle) {
                if (handle.idx != bgfx::kInvalidHandle)
                {
                    bgfx::destroy(handle);
                }
            };
            DoForHandleTypes(nonDynamic, dynamic);
        }

        void EnsureFinalized(Napi::Env /*env*/, const bgfx::VertexLayout& layout)
        {
            const auto nonDynamic = [&layout, this](auto handle) {
                if (handle.idx != bgfx::kInvalidHandle)
                {
                    return;
                }

                const bgfx::Memory* memory = bgfx::makeRef(
                    m_bytes.data(), static_cast<uint32_t>(m_bytes.size()), [](void*, void* userData) {
                        auto* bytes = reinterpret_cast<std::vector<uint8_t>*>(userData);
                        bytes->clear();
                    },
                    &m_bytes);

                m_handle = bgfx::createVertexBuffer(memory, layout);
            };
            const auto dynamic = [&layout, this](auto handle) {
                if (handle.idx != bgfx::kInvalidHandle)
                {
                    return;
                }

                const bgfx::Memory* memory = bgfx::makeRef(
                    m_bytes.data(), static_cast<uint32_t>(m_bytes.size()), [](void*, void* userData) {
                        auto* bytes = reinterpret_cast<std::vector<uint8_t>*>(userData);
                        bytes->clear();
                    },
                    &m_bytes);

                m_handle = bgfx::createDynamicVertexBuffer(memory, layout);
            };
            DoForHandleTypes(nonDynamic, dynamic);
        }

        void Update(Napi::Env env, const Napi::Uint8Array& bytes, uint32_t offset, uint32_t byteLength)
        {
            auto nonDynamic = [env](auto) {
                throw Napi::Error::New(env, ""Cannot update non-dynamic vertex buffer."");
            };
            const auto dynamic = [&bytes, offset, byteLength, this](auto handle) {
                if (handle.idx == bgfx::kInvalidHandle)
                {
                    // Buffer hasn't been finalized yet, all that's necessary is to swap out the bytes.
                    m_bytes = {bytes.Data() + offset, bytes.Data() + offset + byteLength};
                }
                else
                {
                    // Buffer was already created, do a real update operation.
                    const bgfx::Memory* memory = bgfx::copy(bytes.Data() + offset, byteLength);
                    bgfx::update(handle, 0, memory);
                }
            };
            DoForHandleTypes(nonDynamic, dynamic);
        }

        void SetAsBgfxVertexBuffer(uint8_t index, uint32_t startVertex, bgfx::VertexLayoutHandle layout) const
        {
            const auto nonDynamic = [index, startVertex, layout](auto handle) {
                bgfx::setVertexBuffer(index, handle, startVertex, UINT32_MAX, layout);
            };
            const auto dynamic = [index, startVertex, layout](auto handle) {
                bgfx::setVertexBuffer(index, handle, startVertex, UINT32_MAX, layout);
            };
            DoForHandleTypes(nonDynamic, dynamic);
        }

    private:
        std::vector<uint8_t> m_bytes{};
    };

    void NativeEngine::Initialize(Napi::Env env, bool autoRender)
    {
        // Initialize the JavaScript side.
        Napi::HandleScope scope{env};

        Napi::Function func = DefineClass(
            env,
            JS_CLASS_NAME,
            {InstanceMethod(""dispose"", &NativeEngine::Dispose),
                InstanceMethod(""getEngine"", &NativeEngine::GetEngine),
                InstanceAccessor(""homogeneousDepth"", &NativeEngine::HomogeneousDepth, nullptr),
                InstanceMethod(""requestAnimationFrame"", &NativeEngine::RequestAnimationFrame),
                InstanceMethod(""createVertexArray"", &NativeEngine::CreateVertexArray),
                InstanceMethod(""deleteVertexArray"", &NativeEngine::DeleteVertexArray),
                InstanceMethod(""bindVertexArray"", &NativeEngine::BindVertexArray),
                InstanceMethod(""createIndexBuffer"", &NativeEngine::CreateIndexBuffer),
                InstanceMethod(""deleteIndexBuffer"", &NativeEngine::DeleteIndexBuffer),
                InstanceMethod(""recordIndexBuffer"", &NativeEngine::RecordIndexBuffer),
                InstanceMethod(""updateDynamicIndexBuffer"", &NativeEngine::UpdateDynamicIndexBuffer),
                InstanceMethod(""createVertexBuffer"", &NativeEngine::CreateVertexBuffer),
                InstanceMethod(""deleteVertexBuffer"", &NativeEngine::DeleteVertexBuffer),
                InstanceMethod(""recordVertexBuffer"", &NativeEngine::RecordVertexBuffer),
                InstanceMethod(""updateDynamicVertexBuffer"", &NativeEngine::UpdateDynamicVertexBuffer),
                InstanceMethod(""createProgram"", &NativeEngine::CreateProgram),
                InstanceMethod(""getUniforms"", &NativeEngine::GetUniforms),
                InstanceMethod(""getAttributes"", &NativeEngine::GetAttributes),
                InstanceMethod(""setProgram"", &NativeEngine::SetProgram),
                InstanceMethod(""setState"", &NativeEngine::SetState),
                InstanceMethod(""setZOffset"", &NativeEngine::SetZOffset),
                InstanceMethod(""getZOffset"", &NativeEngine::GetZOffset),
                InstanceMethod(""setDepthTest"", &NativeEngine::SetDepthTest),
                InstanceMethod(""getDepthWrite"", &NativeEngine::GetDepthWrite),
                InstanceMethod(""setDepthWrite"", &NativeEngine::SetDepthWrite),
                InstanceMethod(""setColorWrite"", &NativeEngine::SetColorWrite),
                InstanceMethod(""setBlendMode"", &NativeEngine::SetBlendMode),
                InstanceMethod(""setMatrix"", &NativeEngine::SetMatrix),
                InstanceMethod(""setInt"", &NativeEngine::SetInt),
                InstanceMethod(""setIntArray"", &NativeEngine::SetIntArray),
                InstanceMethod(""setIntArray2"", &NativeEngine::SetIntArray2),
                InstanceMethod(""setIntArray3"", &NativeEngine::SetIntArray3),
                InstanceMethod(""setIntArray4"", &NativeEngine::SetIntArray4),
                InstanceMethod(""setFloatArray"", &NativeEngine::SetFloatArray),
                InstanceMethod(""setFloatArray2"", &NativeEngine::SetFloatArray2),
                InstanceMethod(""setFloatArray3"", &NativeEngine::SetFloatArray3),
                InstanceMethod(""setFloatArray4"", &NativeEngine::SetFloatArray4),
                InstanceMethod(""setMatrices"", &NativeEngine::SetMatrices),
                InstanceMethod(""setMatrix3x3"", &NativeEngine::SetMatrix3x3),
                InstanceMethod(""setMatrix2x2"", &NativeEngine::SetMatrix2x2),
                InstanceMethod(""setFloat"", &NativeEngine::SetFloat),
                InstanceMethod(""setFloat2"", &NativeEngine::SetFloat2),
                InstanceMethod(""setFloat3"", &NativeEngine::SetFloat3),
                InstanceMethod(""setFloat4"", &NativeEngine::SetFloat4),
                InstanceMethod(""createTexture"", &NativeEngine::CreateTexture),
                InstanceMethod(""loadTexture"", &NativeEngine::LoadTexture),
                InstanceMethod(""loadRawTexture"", &NativeEngine::LoadRawTexture),
                InstanceMethod(""loadCubeTexture"", &NativeEngine::LoadCubeTexture),
                InstanceMethod(""loadCubeTextureWithMips"", &NativeEngine::LoadCubeTextureWithMips),
                InstanceMethod(""getTextureWidth"", &NativeEngine::GetTextureWidth),
                InstanceMethod(""getTextureHeight"", &NativeEngine::GetTextureHeight),
                InstanceMethod(""setTextureSampling"", &NativeEngine::SetTextureSampling),
                InstanceMethod(""setTextureWrapMode"", &NativeEngine::SetTextureWrapMode),
                InstanceMethod(""setTextureAnisotropicLevel"", &NativeEngine::SetTextureAnisotropicLevel),
                InstanceMethod(""setTexture"", &NativeEngine::SetTexture),
                InstanceMethod(""deleteTexture"", &NativeEngine::DeleteTexture),
                InstanceMethod(""createFramebuffer"", &NativeEngine::CreateFrameBuffer),
                InstanceMethod(""deleteFramebuffer"", &NativeEngine::DeleteFrameBuffer),
                InstanceMethod(""bindFramebuffer"", &NativeEngine::BindFrameBuffer),
                InstanceMethod(""unbindFramebuffer"", &NativeEngine::UnbindFrameBuffer),
                InstanceMethod(""drawIndexed"", &NativeEngine::DrawIndexed),
                InstanceMethod(""draw"", &NativeEngine::Draw),
                InstanceMethod(""clear"", &NativeEngine::Clear),
                InstanceMethod(""getRenderWidth"", &NativeEngine::GetRenderWidth),
                InstanceMethod(""getRenderHeight"", &NativeEngine::GetRenderHeight),
                InstanceMethod(""setViewPort"", &NativeEngine::SetViewPort),
                InstanceMethod(""getFramebufferData"", &NativeEngine::GetFramebufferData),
                InstanceMethod(""getRenderAPI"", &NativeEngine::GetRenderAPI),
                InstanceMethod(""getHardwareScalingLevel"", &NativeEngine::GetHardwareScalingLevel),
                InstanceMethod(""setHardwareScalingLevel"", &NativeEngine::SetHardwareScalingLevel),

                InstanceValue(""TEXTURE_NEAREST_NEAREST"", Napi::Number::From(env, TextureSampling::NEAREST_NEAREST)),
                InstanceValue(""TEXTURE_LINEAR_LINEAR"", Napi::Number::From(env, TextureSampling::LINEAR_LINEAR)),
                InstanceValue(""TEXTURE_LINEAR_LINEAR_MIPLINEAR"", Napi::Number::From(env, TextureSampling::LINEAR_LINEAR_MIPLINEAR)),
                InstanceValue(""TEXTURE_NEAREST_NEAREST_MIPNEAREST"", Napi::Number::From(env, TextureSampling::NEAREST_NEAREST_MIPNEAREST)),
                InstanceValue(""TEXTURE_NEAREST_LINEAR_MIPNEAREST"", Napi::Number::From(env, TextureSampling::NEAREST_LINEAR_MIPNEAREST)),
                InstanceValue(""TEXTURE_NEAREST_LINEAR_MIPLINEAR"", Napi::Number::From(env, TextureSampling::NEAREST_LINEAR_MIPLINEAR)),
                InstanceValue(""TEXTURE_NEAREST_LINEAR"", Napi::Number::From(env, TextureSampling::NEAREST_LINEAR)),
                InstanceValue(""TEXTURE_NEAREST_NEAREST_MIPLINEAR"", Napi::Number::From(env, TextureSampling::NEAREST_NEAREST_MIPLINEAR)),
                InstanceValue(""TEXTURE_LINEAR_NEAREST_MIPNEAREST"", Napi::Number::From(env, TextureSampling::LINEAR_NEAREST_MIPNEAREST)),
                InstanceValue(""TEXTURE_LINEAR_NEAREST_MIPLINEAR"", Napi::Number::From(env, TextureSampling::LINEAR_NEAREST_MIPLINEAR)),
                InstanceValue(""TEXTURE_LINEAR_LINEAR_MIPNEAREST"", Napi::Number::From(env, TextureSampling::LINEAR_LINEAR_MIPNEAREST)),
                InstanceValue(""TEXTURE_LINEAR_NEAREST"", Napi::Number::From(env, TextureSampling::LINEAR_NEAREST)),

                InstanceValue(""DEPTH_TEST_LESS"", Napi::Number::From(env, BGFX_STATE_DEPTH_TEST_LESS)),
                InstanceValue(""DEPTH_TEST_LEQUAL"", Napi::Number::From(env, BGFX_STATE_DEPTH_TEST_LEQUAL)),
                InstanceValue(""DEPTH_TEST_EQUAL"", Napi::Number::From(env, BGFX_STATE_DEPTH_TEST_EQUAL)),
                InstanceValue(""DEPTH_TEST_GEQUAL"", Napi::Number::From(env, BGFX_STATE_DEPTH_TEST_GEQUAL)),
                InstanceValue(""DEPTH_TEST_GREATER"", Napi::Number::From(env, BGFX_STATE_DEPTH_TEST_GREATER)),
                InstanceValue(""DEPTH_TEST_NOTEQUAL"", Napi::Number::From(env, BGFX_STATE_DEPTH_TEST_NOTEQUAL)),
                InstanceValue(""DEPTH_TEST_NEVER"", Napi::Number::From(env, BGFX_STATE_DEPTH_TEST_NEVER)),
                InstanceValue(""DEPTH_TEST_ALWAYS"", Napi::Number::From(env, BGFX_STATE_DEPTH_TEST_ALWAYS)),

                InstanceValue(""CLEAR_FLAG_COLOR"", Napi::Number::From(env, BGFX_CLEAR_COLOR)),
                InstanceValue(""CLEAR_FLAG_DEPTH"", Napi::Number::From(env, BGFX_CLEAR_DEPTH)),
                InstanceValue(""CLEAR_FLAG_STENCIL"", Napi::Number::From(env, BGFX_CLEAR_STENCIL)),

                InstanceValue(""ADDRESS_MODE_WRAP"", Napi::Number::From(env, 0)),
                InstanceValue(""ADDRESS_MODE_MIRROR"", Napi::Number::From(env, BGFX_SAMPLER_U_MIRROR)),
                InstanceValue(""ADDRESS_MODE_CLAMP"", Napi::Number::From(env, BGFX_SAMPLER_U_CLAMP)),
                InstanceValue(""ADDRESS_MODE_BORDER"", Napi::Number::From(env, BGFX_SAMPLER_U_BORDER)),
                InstanceValue(""ADDRESS_MODE_MIRROR_ONCE"", Napi::Number::From(env, BGFX_SAMPLER_U_MIRROR)),

                InstanceValue(""TEXTURE_FORMAT_RGB8"", Napi::Number::From(env, static_cast<uint32_t>(bgfx::TextureFormat::RGB8))),
                InstanceValue(""TEXTURE_FORMAT_RGBA8"", Napi::Number::From(env, static_cast<uint32_t>(bgfx::TextureFormat::RGBA8))),
                InstanceValue(""TEXTURE_FORMAT_RGBA32F"", Napi::Number::From(env, static_cast<uint32_t>(bgfx::TextureFormat::RGBA32F))),

                InstanceValue(""ATTRIB_TYPE_UINT8"", Napi::Number::From(env, static_cast<uint32_t>(bgfx::AttribType::Uint8))),
                InstanceValue(""ATTRIB_TYPE_INT16"", Napi::Number::From(env, static_cast<uint32_t>(bgfx::AttribType::Int16))),
                InstanceValue(""ATTRIB_TYPE_FLOAT"", Napi::Number::From(env, static_cast<uint32_t>(bgfx::AttribType::Float))),

                InstanceValue(""ALPHA_DISABLE"", Napi::Number::From(env, AlphaMode::DISABLE)),
                InstanceValue(""ALPHA_ADD"", Napi::Number::From(env, AlphaMode::ADD)),
                InstanceValue(""ALPHA_COMBINE"", Napi::Number::From(env, AlphaMode::COMBINE)),
                InstanceValue(""ALPHA_SUBTRACT"", Napi::Number::From(env, AlphaMode::SUBTRACT)),
                InstanceValue(""ALPHA_MULTIPLY"", Napi::Number::From(env, AlphaMode::MULTIPLY)),
                InstanceValue(""ALPHA_MAXIMIZED"", Napi::Number::From(env, AlphaMode::MAXIMIZED)),
                InstanceValue(""ALPHA_ONEONE"", Napi::Number::From(env, AlphaMode::ONEONE)),
                InstanceValue(""ALPHA_PREMULTIPLIED"", Napi::Number::From(env, AlphaMode::PREMULTIPLIED)),
                InstanceValue(""ALPHA_PREMULTIPLIED_PORTERDUFF"", Napi::Number::From(env, AlphaMode::PREMULTIPLIED_PORTERDUFF)),
                InstanceValue(""ALPHA_INTERPOLATE"", Napi::Number::From(env, AlphaMode::INTERPOLATE)),
                InstanceValue(""ALPHA_SCREENMODE"", Napi::Number::From(env, AlphaMode::SCREENMODE)),

                InstanceValue(JS_AUTO_RENDER_PROPERTY_NAME, Napi::Boolean::New(env, autoRender))});

        JsRuntime::NativeObject::GetFromJavaScript(env).Set(JS_ENGINE_CONSTRUCTOR_NAME, func);

        if (autoRender)
        {
            Graphics::Impl::GetFromJavaScript(env).EnableRendering();
        }
    }

    NativeEngine::NativeEngine(const Napi::CallbackInfo& info)
        : NativeEngine(info, JsRuntime::GetFromJavaScript(info.Env()))
    {
    }

    NativeEngine::NativeEngine(const Napi::CallbackInfo& info, JsRuntime& runtime)
        : Napi::ObjectWrap<NativeEngine>{info}
        , AutomaticRenderingEnabled{info.This().As<Napi::Object>().Get(JS_AUTO_RENDER_PROPERTY_NAME).ToBoolean()}
        , RuntimeScheduler{runtime}
        , m_runtime{runtime}
        , m_graphicsImpl{Graphics::Impl::GetFromJavaScript(info.Env())}
        , m_engineState{BGFX_STATE_DEFAULT}
    {
    }

    NativeEngine::~NativeEngine()
    {
        Dispose();
    }

    template<typename SchedulerT>
    arcana::task<void, std::exception_ptr> NativeEngine::GetRequestAnimationFrameTask(SchedulerT& scheduler)
    {
        return arcana::make_task(scheduler, m_cancelSource, [this] {
            m_isRenderScheduled = false;

            if (!m_requestAnimationFrameCallback.IsEmpty())
            {
                // We can get here from either the normal RequestAnimationFrame or the XR RequestAnimationFrame,
                // so we need to clear out the regular RequestAnimationFrame callback to make sure we don't incorrectly
                // call it when we have transitioned to the XR RequestAnimationFrame.
                auto callback{std::move(m_requestAnimationFrameCallback)};
                callback({});
            }

            GetFrameBufferManager().Reset();
        });
    }

    void NativeEngine::ScheduleRender()
    {
        if (!m_isRenderScheduled)
        {
            m_isRenderScheduled = true;

            m_graphicsImpl.GetBeforeRenderTask().then(arcana::inline_scheduler, m_cancelSource, [this]() mutable {
                if (AutomaticRenderingEnabled)
                {
                    m_graphicsImpl.AddRenderWorkTask(GetRequestAnimationFrameTask(arcana::inline_scheduler));
                }
                else
                {
                    m_graphicsImpl.AddRenderWorkTask(GetRequestAnimationFrameTask(RuntimeScheduler));
                }
            });
            if (AutomaticRenderingEnabled)
            {
                Dispatch([this] {
                    m_graphicsImpl.RenderCurrentFrame();
                });
            }
        }
    }

    FrameBufferManager& NativeEngine::GetFrameBufferManager()
    {
        return m_frameBufferManager;
    }

    void NativeEngine::Dispose()
    {
        m_cancelSource.cancel();

        // This collection contains bgfx data, so it must be cleared before bgfx::shutdown is called.
        m_programDataCollection.clear();
    }

    void NativeEngine::Dispose(const Napi::CallbackInfo& /*info*/)
    {
        Dispose();
    }

    // NativeEngine definitions
    Napi::Value NativeEngine::GetEngine(const Napi::CallbackInfo& info)
    {
        return Napi::External<NativeEngine>::New(info.Env(), this);
    }

    Napi::Value NativeEngine::HomogeneousDepth(const Napi::CallbackInfo& info)
    {
        return Napi::Value::From(info.Env(), bgfx::getCaps()->homogeneousDepth);
    }

    void NativeEngine::RequestAnimationFrame(const Napi::CallbackInfo& info)
    {
        auto callback = info[0].As<Napi::Function>();

        if (m_requestAnimationFrameCallback.IsEmpty() ||
            m_requestAnimationFrameCallback.Value() != callback)
        {
            m_requestAnimationFrameCallback = Napi::Persistent(callback);
        }

        ScheduleRender();
    }

    Napi::Value NativeEngine::CreateVertexArray(const Napi::CallbackInfo& info)
    {
        return Napi::External<VertexArray>::New(info.Env(), new VertexArray{});
    }

    void NativeEngine::DeleteVertexArray(const Napi::CallbackInfo& info)
    {
        delete info[0].As<Napi::External<VertexArray>>().Data();
    }

    void NativeEngine::BindVertexArray(const Napi::CallbackInfo& info)
    {
        const auto& vertexArray = *(info[0].As<Napi::External<VertexArray>>().Data());

        // a vertex array might not have an index buffer associated with
        m_currentBoundIndexBuffer = vertexArray.indexBuffer.data;

        const auto& vertexBuffers = vertexArray.vertexBuffers;
        for (auto vertexBufferPair : vertexBuffers)
        {
            const auto& vertexBuffer = vertexBufferPair.second;
            vertexBuffer.data->SetAsBgfxVertexBuffer(static_cast<uint8_t>(vertexBufferPair.first), vertexBuffer.startVertex, vertexBuffer.vertexLayoutHandle);
        }
    }

    Napi::Value NativeEngine::CreateIndexBuffer(const Napi::CallbackInfo& info)
    {
        const Napi::TypedArray data = info[0].As<Napi::TypedArray>();
        const bool dynamic = info[1].As<Napi::Boolean>().Value();

        const uint16_t flags = data.TypedArrayType() == napi_typedarray_type::napi_uint16_array ? 0 : BGFX_BUFFER_INDEX32;

        return Napi::External<IndexBufferData>::New(info.Env(), new IndexBufferData(data, flags, dynamic));
    }

    void NativeEngine::DeleteIndexBuffer(const Napi::CallbackInfo& info)
    {
        IndexBufferData* indexBufferData = info[0].As<Napi::External<IndexBufferData>>().Data();
        delete indexBufferData;
    }

    void NativeEngine::RecordIndexBuffer(const Napi::CallbackInfo& info)
    {
        VertexArray& vertexArray = *(info[0].As<Napi::External<VertexArray>>().Data());
        const IndexBufferData* indexBufferData = info[1].As<Napi::External<IndexBufferData>>().Data();

        vertexArray.indexBuffer.data = indexBufferData;
    }

    void NativeEngine::UpdateDynamicIndexBuffer(const Napi::CallbackInfo& info)
    {
        IndexBufferData& indexBufferData = *(info[0].As<Napi::External<IndexBufferData>>().Data());

        const Napi::TypedArray data = info[1].As<Napi::TypedArray>();
        const uint32_t startingIdx = info[2].As<Napi::Number>().Uint32Value();

        indexBufferData.Update(info.Env(), data, startingIdx);
    }

    Napi::Value NativeEngine::CreateVertexBuffer(const Napi::CallbackInfo& info)
    {
        const Napi::Uint8Array data = info[0].As<Napi::Uint8Array>();
        const bool dynamic = info[1].As<Napi::Boolean>().Value();

        return Napi::External<VertexBufferData>::New(info.Env(), new VertexBufferData(data, dynamic));
    }

    void NativeEngine::DeleteVertexBuffer(const Napi::CallbackInfo& info)
    {
        auto* vertexBufferData = info[0].As<Napi::External<VertexBufferData>>().Data();
        delete vertexBufferData;
    }

    void NativeEngine::RecordVertexBuffer(const Napi::CallbackInfo& info)
    {
        VertexArray& vertexArray = *(info[0].As<Napi::External<VertexArray>>().Data());
        VertexBufferData* vertexBufferData = info[1].As<Napi::External<VertexBufferData>>().Data();

        const uint32_t location = info[2].As<Napi::Number>().Uint32Value();
        const uint32_t byteOffset = info[3].As<Napi::Number>().Uint32Value();
        const uint32_t byteStride = info[4].As<Napi::Number>().Uint32Value();
        const uint32_t numElements = info[5].As<Napi::Number>().Uint32Value();
        const uint32_t type = info[6].As<Napi::Number>().Uint32Value();
        const bool normalized = info[7].As<Napi::Boolean>().Value();

        bgfx::VertexLayout vertexLayout{};
        vertexLayout.begin();

        const bgfx::Attrib::Enum attrib = static_cast<bgfx::Attrib::Enum>(location);
        const auto attribType = static_cast<bgfx::AttribType::Enum>(type);
        vertexLayout.add(attrib, static_cast<uint8_t>(numElements), attribType, normalized);
        vertexLayout.m_stride = static_cast<uint16_t>(byteStride);
        vertexLayout.end();

        vertexBufferData->EnsureFinalized(info.Env(), vertexLayout);

        vertexArray.vertexBuffers[location] = {vertexBufferData, byteOffset / byteStride, bgfx::createVertexLayout(vertexLayout)};
    }

    void NativeEngine::UpdateDynamicVertexBuffer(const Napi::CallbackInfo& info)
    {
        VertexBufferData& vertexBufferData = *(info[0].As<Napi::External<VertexBufferData>>().Data());
        const Napi::Uint8Array data = info[1].As<Napi::Uint8Array>();
        const uint32_t byteOffset = info[2].As<Napi::Number>().Uint32Value();

        uint32_t byteLength = info[2].As<Napi::Number>().Uint32Value();
        if (byteLength == 0)
        {
            byteLength = static_cast<uint32_t>(data.ByteLength());
        }

        vertexBufferData.Update(info.Env(), data, byteOffset, byteLength);
    }

    Napi::Value NativeEngine::CreateProgram(const Napi::CallbackInfo& info)
    {
        const std::string vertexSource{info[0].As<Napi::String>().Utf8Value()};
        const std::string fragmentSource{info[1].As<Napi::String>().Utf8Value()};

        std::unique_ptr<ProgramData> programData{std::make_unique<ProgramData>()};
        ShaderCompiler::BgfxShaderInfo shaderInfo{};

        try
        {
            shaderInfo = m_shaderCompiler.Compile(vertexSource, fragmentSource);
        }
        catch (const std::exception& ex)
        {
            throw Napi::Error::New(info.Env(), ex.what());
        }

        static auto InitUniformInfos{[](bgfx::ShaderHandle shader, const std::unordered_map<std::string, uint8_t>& uniformStages, std::unordered_map<std::string, UniformInfo>& uniformInfos) {
            auto numUniforms = bgfx::getShaderUniforms(shader);
            std::vector<bgfx::UniformHandle> uniforms{numUniforms};
            bgfx::getShaderUniforms(shader, uniforms.data(), gsl::narrow_cast<uint16_t>(uniforms.size()));

            for (uint8_t index = 0; index < numUniforms; index++)
            {
                bgfx::UniformInfo info{};
                bgfx::getUniformInfo(uniforms[index], info);
                auto itStage = uniformStages.find(info.name);
                uniformInfos[info.name] = {itStage == uniformStages.end() ? uint8_t{} : itStage->second, uniforms[index]};
                bool YFlip{false};
                if (!bgfx::getCaps()->originBottomLeft)
                {
                    YFlip = (!strcmp(info.name, ""projection"")) || (!strcmp(info.name, ""viewProjection""));
                }
                uniformInfos[info.name].YFlip = YFlip;
            }
        }};

        auto vertexShader = bgfx::createShader(bgfx::copy(shaderInfo.VertexBytes.data(), static_cast<uint32_t>(shaderInfo.VertexBytes.size())));
        InitUniformInfos(vertexShader, shaderInfo.VertexUniformStages, programData->VertexUniformInfos);
        programData->VertexAttributeLocations = std::move(shaderInfo.VertexAttributeLocations);

        auto fragmentShader = bgfx::createShader(bgfx::copy(shaderInfo.FragmentBytes.data(), static_cast<uint32_t>(shaderInfo.FragmentBytes.size())));
        InitUniformInfos(fragmentShader, shaderInfo.FragmentUniformStages, programData->FragmentUniformInfos);

        programData->Program = bgfx::createProgram(vertexShader, fragmentShader, true);
        auto* rawProgramData = programData.get();
        auto ticket = m_programDataCollection.insert(std::move(programData));
        auto finalizer = [ticket = std::move(ticket)](Napi::Env, ProgramData*) {};
        return Napi::External<ProgramData>::New(info.Env(), rawProgramData, std::move(finalizer));
    }

    Napi::Value NativeEngine::GetUniforms(const Napi::CallbackInfo& info)
    {
        const auto program = info[0].As<Napi::External<ProgramData>>().Data();
        const auto names = info[1].As<Napi::Array>();

        auto length = names.Length();
        auto uniforms = Napi::Array::New(info.Env(), length);
        for (uint32_t index = 0; index < length; ++index)
        {
            const auto name = names[index].As<Napi::String>().Utf8Value();

            auto vertexFound = program->VertexUniformInfos.find(name);
            auto fragmentFound = program->FragmentUniformInfos.find(name);

            if (vertexFound != program->VertexUniformInfos.end())
            {
                uniforms[index] = Napi::External<UniformInfo>::New(info.Env(), &vertexFound->second);
            }
            else if (fragmentFound != program->FragmentUniformInfos.end())
            {
                uniforms[index] = Napi::External<UniformInfo>::New(info.Env(), &fragmentFound->second);
            }
            else
            {
                uniforms[index] = info.Env().Null();
            }
        }

        return std::move(uniforms);
    }

    Napi::Value NativeEngine::GetAttributes(const Napi::CallbackInfo& info)
    {
        const auto program = info[0].As<Napi::External<ProgramData>>().Data();
        const auto names = info[1].As<Napi::Array>();

        const auto& attributeLocations = program->VertexAttributeLocations;

        auto length = names.Length();
        auto attributes = Napi::Array::New(info.Env(), length);
        for (uint32_t index = 0; index < length; ++index)
        {
            const std::string name = names[index].As<Napi::String>().Utf8Value();
            const auto it = attributeLocations.find(name);
            int location = (it == attributeLocations.end() ? -1 : gsl::narrow_cast<int>(it->second));
            attributes[index] = Napi::Value::From(info.Env(), location);
        }

        return std::move(attributes);
    }

    void NativeEngine::SetProgram(const Napi::CallbackInfo& info)
    {
        auto program = info[0].As<Napi::External<ProgramData>>().Data();
        m_currentProgram = program;
    }

    void NativeEngine::SetState(const Napi::CallbackInfo& info)
    {
        const auto culling = info[0].As<Napi::Boolean>().Value();
        const auto cullBackFaces = info[2].As<Napi::Boolean>().Value();
        const auto reverseSide = info[3].As<Napi::Boolean>().Value();

        m_engineState &= ~(BGFX_STATE_CULL_MASK | BGFX_STATE_FRONT_CCW);
        m_engineState |= reverseSide ? 0 : BGFX_STATE_FRONT_CCW;

        if (culling)
        {
            m_engineState |= cullBackFaces ? BGFX_STATE_CULL_CCW : BGFX_STATE_CULL_CW;
        }
        // TODO: zOffset
        //const auto zOffset = info[1].As<Napi::Number>().FloatValue();
    }

    void NativeEngine::SetZOffset(const Napi::CallbackInfo& /*info*/)
    {
        //const auto zOffset = info[0].As<Napi::Number>().FloatValue();

        // STUB: Stub.
    }

    Napi::Value NativeEngine::GetZOffset(const Napi::CallbackInfo& /*info*/)
    {
        // STUB: Stub.
        return {};
    }

    void NativeEngine::SetDepthTest(const Napi::CallbackInfo& info)
    {
        const auto depthTest = info[0].As<Napi::Number>().Uint32Value();

        m_engineState &= ~BGFX_STATE_DEPTH_TEST_MASK;
        m_engineState |= depthTest;
    }

    Napi::Value NativeEngine::GetDepthWrite(const Napi::CallbackInfo& info)
    {
        return Napi::Value::From(info.Env(), !!(m_engineState & BGFX_STATE_WRITE_Z));
    }

    void NativeEngine::SetDepthWrite(const Napi::CallbackInfo& info)
    {
        const auto enable = info[0].As<Napi::Boolean>().Value();

        m_engineState &= ~BGFX_STATE_WRITE_Z;
        m_engineState |= enable ? BGFX_STATE_WRITE_Z : 0;
    }

    void NativeEngine::SetColorWrite(const Napi::CallbackInfo& info)
    {
        const auto enable = info[0].As<Napi::Boolean>().Value();

        m_engineState &= ~(BGFX_STATE_WRITE_RGB | BGFX_STATE_WRITE_A);
        m_engineState |= enable ? (BGFX_STATE_WRITE_RGB | BGFX_STATE_WRITE_A) : 0;
    }

    void NativeEngine::SetBlendMode(const Napi::CallbackInfo& info)
    {
        const auto blendMode = info[0].As<Napi::Number>().Int64Value();

        m_engineState &= ~BGFX_STATE_BLEND_MASK;
        m_engineState |= blendMode;
    }

    void NativeEngine::SetInt(const Napi::CallbackInfo& info)
    {
        const auto uniformInfo = info[0].As<Napi::External<UniformInfo>>().Data();
        const auto value = info[1].As<Napi::Number>().FloatValue();
        m_currentProgram->SetUniform(uniformInfo->Handle, gsl::make_span(&value, 1), uniformInfo->YFlip);
    }

    template<int size, typename arrayType>
    void NativeEngine::SetTypeArrayN(const Napi::CallbackInfo& info)
    {
        const auto uniformInfo = info[0].As<Napi::External<UniformInfo>>().Data();
        const auto array = info[1].As<arrayType>();

        size_t elementLength = array.ElementLength();

        m_scratch.clear();
        for (size_t index = 0; index < elementLength; index += size)
        {
            const float values[] = {
                static_cast<float>(array[index]),
                (size > 1) ? static_cast<float>(array[index + 1]) : 0.f,
                (size > 2) ? static_cast<float>(array[index + 2]) : 0.f,
                (size > 3) ? static_cast<float>(array[index + 3]) : 0.f,
            };
            m_scratch.insert(m_scratch.end(), values, values + 4);
        }

        m_currentProgram->SetUniform(uniformInfo->Handle, m_scratch, uniformInfo->YFlip, elementLength / size);
    }

    template<int size>
    void NativeEngine::SetFloatN(const Napi::CallbackInfo& info)
    {
        const auto uniformInfo = info[0].As<Napi::External<UniformInfo>>().Data();
        const float values[] = {
            info[1].As<Napi::Number>().FloatValue(),
            (size > 1) ? info[2].As<Napi::Number>().FloatValue() : 0.f,
            (size > 2) ? info[3].As<Napi::Number>().FloatValue() : 0.f,
            (size > 3) ? info[4].As<Napi::Number>().FloatValue() : 0.f,
        };

        m_currentProgram->SetUniform(uniformInfo->Handle, values, uniformInfo->YFlip);
    }

    template<int size>
    void NativeEngine::SetMatrixN(const Napi::CallbackInfo& info)
    {
        const auto uniformInfo = info[0].As<Napi::External<UniformInfo>>().Data();
        const auto matrix = info[1].As<Napi::Float32Array>();

        const size_t elementLength = matrix.ElementLength();
        assert(elementLength == size * size);
        (void)elementLength;

        if constexpr (size < 4)
        {
            std::array<float, 16> matrixValues{};

            size_t index = 0;
            for (int line = 0; line < size; line++)
            {
                for (int col = 0; col < size; col++)
                {
                    matrixValues[line * 4 + col] = matrix[index++];
                }
            }

            m_currentProgram->SetUniform(uniformInfo->Handle, gsl::make_span(matrixValues.data(), 16), uniformInfo->YFlip);
        }
        else
        {
            m_currentProgram->SetUniform(uniformInfo->Handle, gsl::make_span(matrix.Data(), elementLength), uniformInfo->YFlip);
        }
    }

    void NativeEngine::SetIntArray(const Napi::CallbackInfo& info)
    {
        SetTypeArrayN<1, Napi::Int32Array>(info);
    }

    void NativeEngine::SetIntArray2(const Napi::CallbackInfo& info)
    {
        SetTypeArrayN<2, Napi::Int32Array>(info);
    }

    void NativeEngine::SetIntArray3(const Napi::CallbackInfo& info)
    {
        SetTypeArrayN<3, Napi::Int32Array>(info);
    }

    void NativeEngine::SetIntArray4(const Napi::CallbackInfo& info)
    {
        SetTypeArrayN<4, Napi::Int32Array>(info);
    }

    void NativeEngine::SetFloatArray(const Napi::CallbackInfo& info)
    {
        SetTypeArrayN<1, Napi::Float32Array>(info);
    }

    void NativeEngine::SetFloatArray2(const Napi::CallbackInfo& info)
    {
        SetTypeArrayN<2, Napi::Float32Array>(info);
    }

    void NativeEngine::SetFloatArray3(const Napi::CallbackInfo& info)
    {
        SetTypeArrayN<3, Napi::Float32Array>(info);
    }

    void NativeEngine::SetFloatArray4(const Napi::CallbackInfo& info)
    {
        SetTypeArrayN<4, Napi::Float32Array>(info);
    }

    void NativeEngine::SetMatrices(const Napi::CallbackInfo& info)
    {
        const auto uniformInfo = info[0].As<Napi::External<UniformInfo>>().Data();
        const auto matricesArray = info[1].As<Napi::Float32Array>();

        const size_t elementLength = matricesArray.ElementLength();
        assert(elementLength % 16 == 0);

        m_currentProgram->SetUniform(uniformInfo->Handle, gsl::span(matricesArray.Data(), elementLength), uniformInfo->YFlip, elementLength / 16);
    }

    void NativeEngine::SetMatrix2x2(const Napi::CallbackInfo& info)
    {
        SetMatrixN<2>(info);
    }

    void NativeEngine::SetMatrix3x3(const Napi::CallbackInfo& info)
    {
        SetMatrixN<3>(info);
    }

    void NativeEngine::SetMatrix(const Napi::CallbackInfo& info)
    {
        SetMatrixN<4>(info);
    }

    void NativeEngine::SetFloat(const Napi::CallbackInfo& info)
    {
        SetFloatN<1>(info);
    }

    void NativeEngine::SetFloat2(const Napi::CallbackInfo& info)
    {
        SetFloatN<2>(info);
    }

    void NativeEngine::SetFloat3(const Napi::CallbackInfo& info)
    {
        SetFloatN<3>(info);
    }

    void NativeEngine::SetFloat4(const Napi::CallbackInfo& info)
    {
        SetFloatN<4>(info);
    }

    Napi::Value NativeEngine::CreateTexture(const Napi::CallbackInfo& info)
    {
        return Napi::External<TextureData>::New(info.Env(), new TextureData());
    }

    void NativeEngine::LoadTexture(const Napi::CallbackInfo& info)
    {
        const auto texture = info[0].As<Napi::External<TextureData>>().Data();
        const auto data = info[1].As<Napi::TypedArray>();
        const auto generateMips = info[2].As<Napi::Boolean>().Value();
        const auto invertY = info[3].As<Napi::Boolean>().Value();
        const auto onSuccess = info[4].As<Napi::Function>();
        const auto onError = info[5].As<Napi::Function>();

        const auto dataSpan = gsl::make_span(static_cast<uint8_t*>(data.ArrayBuffer().Data()) + data.ByteOffset(), data.ByteLength());

        arcana::make_task(arcana::threadpool_scheduler, m_cancelSource,
            [this, dataSpan, generateMips, invertY]() {
                bimg::ImageContainer* image = bimg::imageParse(&m_allocator, dataSpan.data(), static_cast<uint32_t>(dataSpan.size()));
                if (image == nullptr)
                {
                    throw std::runtime_error(""Unable to decode image.""); // exception will be forwarded to JS
                }
                if (image->m_format == bimg::TextureFormat::R8)
                {
                    // Images with only 1 channel are interpreted as luminance texture with RGB containing the same value as R and alpha as 255
                    // To emulate this behavior, the format is switched to alpha8 and converted to RGB8 when packing and unpacking take care of 
                    // component swizzling.
                    image->m_format = bimg::TextureFormat::A8;
                    bimg::ImageContainer* rgba = bimg::imageConvert(&m_allocator, bimg::TextureFormat::RGB8, *image, false);
                    bimg::imageFree(image);
                    image = rgba;
                }
                if (invertY)
                {
                    FlipY(image);
                }
                if (generateMips)
                {
                    GenerateMips(&m_allocator, &image);
                }
                return image;
            })
            .then(RuntimeScheduler, arcana::cancellation::none(), [this, texture, dataRef{Napi::Persistent(data)}](bimg::ImageContainer* image) {
                ScheduleRender();
                return m_graphicsImpl.GetAfterRenderTask().then(arcana::inline_scheduler, m_cancelSource, [texture, image] {
                    CreateTextureFromImage(texture, image);
                });
            })
            .then(RuntimeScheduler, m_cancelSource, [onSuccessRef{Napi::Persistent(onSuccess)}, onErrorRef{Napi::Persistent(onError)}](arcana::expected<void, std::exception_ptr> result) {
                if (result.has_error())
                {
                    onErrorRef.Call({});
                }
                else
                {
                    onSuccessRef.Call({});
                }
            });
    }

    void NativeEngine::LoadRawTexture(const Napi::CallbackInfo& info)
    {
        const auto texture = info[0].As<Napi::External<TextureData>>().Data();
        const auto data = info[1].As<Napi::TypedArray>();
        const auto width = info[2].As<Napi::Number>().Uint32Value();
        const auto height = info[3].As<Napi::Number>().Uint32Value();
        const auto format = static_cast<bimg::TextureFormat::Enum>(info[4].As<Napi::Number>().Uint32Value());
        const auto generateMips = info[5].As<Napi::Boolean>().Value();
        const auto invertY = info[6].As<Napi::Boolean>().Value();

        const auto bytes = static_cast<uint8_t*>(data.ArrayBuffer().Data()) + data.ByteOffset();

        bimg::ImageContainer* image = bimg::imageAlloc(&m_allocator, format, static_cast<uint16_t>(width), static_cast<uint16_t>(height), 1, 1, false, false, bytes);
        if (invertY)
        {
            FlipY(image);
        }
        if (generateMips)
        {
            GenerateMips(&m_allocator, &image);
        }
        CreateTextureFromImage(texture, image);
    }

    void NativeEngine::LoadCubeTexture(const Napi::CallbackInfo& info)
    {
        const auto texture = info[0].As<Napi::External<TextureData>>().Data();
        const auto data = info[1].As<Napi::Array>();
        const auto generateMips = info[2].As<Napi::Boolean>().Value();
        const auto onSuccess = info[3].As<Napi::Function>();
        const auto onError = info[4].As<Napi::Function>();

        std::array<Napi::Reference<Napi::TypedArray>, 6> dataRefs;
        std::array<arcana::task<bimg::ImageContainer*, std::exception_ptr>, 6> tasks;
        for (uint32_t face = 0; face < data.Length(); face++)
        {
            const auto typedArray = data[face].As<Napi::TypedArray>();
            const auto dataSpan = gsl::make_span(static_cast<uint8_t*>(typedArray.ArrayBuffer().Data()) + typedArray.ByteOffset(), typedArray.ByteLength());
            dataRefs[face] = Napi::Persistent(typedArray);
            tasks[face] = arcana::make_task(arcana::threadpool_scheduler, m_cancelSource, [this, dataSpan, generateMips]() {
                bimg::ImageContainer* image = bimg::imageParse(&m_allocator, dataSpan.data(), static_cast<uint32_t>(dataSpan.size()));
                // if texture is R8, it needs to be converted as luminance (r=g=b=luminance and alpha = 1)
                // see what's done in loadTexture
                // keeping an assert here until we find some assets to test.
                assert(image->m_format != bimg::TextureFormat::R8);
                if (generateMips)
                {
                    GenerateMips(&m_allocator, &image);
                }
                return image;
            });
        }

        arcana::when_all(gsl::make_span(tasks))
            .then(RuntimeScheduler, arcana::cancellation::none(), [this, texture, generateMips, dataRefs{std::move(dataRefs)}](std::vector<bimg::ImageContainer*> images) {
                ScheduleRender();
                return m_graphicsImpl.GetAfterRenderTask().then(arcana::inline_scheduler, m_cancelSource, [texture, generateMips, images = std::move(images)] {
                    CreateCubeTextureFromImages(texture, images, generateMips);
                });
            })
            .then(RuntimeScheduler, m_cancelSource, [onSuccessRef{Napi::Persistent(onSuccess)}, onErrorRef{Napi::Persistent(onError)}](arcana::expected<void, std::exception_ptr> result) {
                if (result.has_error())
                {
                    onErrorRef.Call({});
                }
                else
                {
                    onSuccessRef.Call({});
                }
            });
    }

    void NativeEngine::LoadCubeTextureWithMips(const Napi::CallbackInfo& info)
    {
        const auto texture = info[0].As<Napi::External<TextureData>>().Data();
        const auto data = info[1].As<Napi::Array>();
        const auto onSuccess = info[2].As<Napi::Function>();
        const auto onError = info[3].As<Napi::Function>();

        const auto numMips = data.Length();
        std::vector<Napi::Reference<Napi::TypedArray>> dataRefs(6 * numMips);
        std::vector<arcana::task<bimg::ImageContainer*, std::exception_ptr>> tasks(6 * numMips);
        for (uint32_t mip = 0; mip < numMips; mip++)
        {
            const auto faceData = data[mip].As<Napi::Array>();
            for (uint32_t face = 0; face < 6; face++)
            {
                const auto typedArray = faceData[face].As<Napi::TypedArray>();
                const auto dataSpan = gsl::make_span(static_cast<uint8_t*>(typedArray.ArrayBuffer().Data()) + typedArray.ByteOffset(), typedArray.ByteLength());
                dataRefs[(face * numMips) + mip] = Napi::Persistent(typedArray);
                tasks[(face * numMips) + mip] = arcana::make_task(arcana::threadpool_scheduler, m_cancelSource, [this, dataSpan]() {
                    bimg::ImageContainer* image = bimg::imageParse(&m_allocator, dataSpan.data(), static_cast<uint32_t>(dataSpan.size()));
                    assert(image->m_format != bimg::TextureFormat::R8);
                    FlipY(image);
                    return image;
                });
            }
        }

        arcana::when_all(gsl::make_span(tasks))
            .then(RuntimeScheduler, arcana::cancellation::none(), [this, texture, dataRefs{std::move(dataRefs)}](std::vector<bimg::ImageContainer*> images) {
                ScheduleRender();
                return m_graphicsImpl.GetAfterRenderTask().then(arcana::inline_scheduler, m_cancelSource, [texture, images = std::move(images)] {
                    CreateCubeTextureFromImages(texture, images, true);
                });
            })
            .then(RuntimeScheduler, m_cancelSource, [onSuccessRef{Napi::Persistent(onSuccess)}, onErrorRef{Napi::Persistent(onError)}](arcana::expected<void, std::exception_ptr> result) {
                if (result.has_error())
                {
                    onErrorRef.Call({});
                }
                else
                {
                    onSuccessRef.Call({});
                }
            });
    }

    Napi::Value NativeEngine::GetTextureWidth(const Napi::CallbackInfo& info)
    {
        const auto texture = info[0].As<Napi::External<TextureData>>().Data();
        return Napi::Value::From(info.Env(), texture->Width);
    }

    Napi::Value NativeEngine::GetTextureHeight(const Napi::CallbackInfo& info)
    {
        const auto texture = info[0].As<Napi::External<TextureData>>().Data();
        return Napi::Value::From(info.Env(), texture->Height);
    }

    void NativeEngine::SetTextureSampling(const Napi::CallbackInfo& info)
    {
        const auto texture = info[0].As<Napi::External<TextureData>>().Data();
        auto filter = static_cast<uint32_t>(info[1].As<Napi::Number>().Uint32Value());

        texture->Flags &= ~(BGFX_SAMPLER_MIN_MASK | BGFX_SAMPLER_MAG_MASK | BGFX_SAMPLER_MIP_MASK);

        if (texture->AnisotropicLevel > 1)
        {
            texture->Flags |= BGFX_SAMPLER_MIN_ANISOTROPIC | BGFX_SAMPLER_MAG_ANISOTROPIC;
        }
        else
        {
            texture->Flags |= filter;
        }
    }

    void NativeEngine::SetTextureWrapMode(const Napi::CallbackInfo& info)
    {
        const auto texture = info[0].As<Napi::External<TextureData>>().Data();
        auto addressModeU = static_cast<uint32_t>(info[1].As<Napi::Number>().Uint32Value());
        auto addressModeV = static_cast<uint32_t>(info[2].As<Napi::Number>().Uint32Value());
        auto addressModeW = static_cast<uint32_t>(info[3].As<Napi::Number>().Uint32Value());

        uint32_t addressMode = addressModeU +
            (addressModeV << BGFX_SAMPLER_V_SHIFT) +
            (addressModeW << BGFX_SAMPLER_W_SHIFT);

        texture->Flags &= ~(BGFX_SAMPLER_U_MASK | BGFX_SAMPLER_V_MASK | BGFX_SAMPLER_W_MASK);
        texture->Flags |= addressMode;
    }

    void NativeEngine::SetTextureAnisotropicLevel(const Napi::CallbackInfo& info)
    {
        const auto texture = info[0].As<Napi::External<TextureData>>().Data();
        const auto value = info[1].As<Napi::Number>().Uint32Value();

        texture->AnisotropicLevel = static_cast<uint8_t>(value);

        // if Anisotropic is set to 0 after being >1, then set texture flags back to linear
        texture->Flags &= ~(BGFX_SAMPLER_MIN_MASK | BGFX_SAMPLER_MAG_MASK | BGFX_SAMPLER_MIP_MASK);
        if (value)
        {
            texture->Flags |= BGFX_SAMPLER_MIN_ANISOTROPIC | BGFX_SAMPLER_MAG_ANISOTROPIC;
        }
    }

    void NativeEngine::SetTexture(const Napi::CallbackInfo& info)
    {
        const auto uniformInfo = info[0].As<Napi::External<UniformInfo>>().Data();
        const auto texture = info[1].As<Napi::External<TextureData>>().Data();

        bgfx::setTexture(uniformInfo->Stage, uniformInfo->Handle, texture->Handle, texture->Flags);
    }

    void NativeEngine::DeleteTexture(const Napi::CallbackInfo& info)
    {
        const auto texture = info[0].As<Napi::External<TextureData>>().Data();
        delete texture;
    }

    Napi::Value NativeEngine::CreateFrameBuffer(const Napi::CallbackInfo& info)
    {
        const auto texture = info[0].As<Napi::External<TextureData>>().Data();
        uint16_t width = static_cast<uint16_t>(info[1].As<Napi::Number>().Uint32Value());
        uint16_t height = static_cast<uint16_t>(info[2].As<Napi::Number>().Uint32Value());
        auto format = static_cast<bgfx::TextureFormat::Enum>(info[3].As<Napi::Number>().Uint32Value());
        //int samplingMode = info[4].As<Napi::Number>().Uint32Value();
        bool generateStencilBuffer = info[5].As<Napi::Boolean>();
        bool generateDepth = info[6].As<Napi::Boolean>();
        bool generateMips = info[7].As<Napi::Boolean>();

        bgfx::FrameBufferHandle frameBufferHandle{};
        if (generateStencilBuffer && !generateDepth)
        {
            throw std::runtime_error{""Does this case even make any sense?""};
        }
        else if (!generateStencilBuffer && !generateDepth)
        {
            frameBufferHandle = bgfx::createFrameBuffer(width, height, format, BGFX_TEXTURE_RT);
        }
        else
        {
            auto depthStencilFormat = bgfx::TextureFormat::D32;
            if (generateStencilBuffer)
            {
                depthStencilFormat = bgfx::TextureFormat::D24S8;
            }

            assert(bgfx::isTextureValid(0, false, 1, format, BGFX_TEXTURE_RT));
            assert(bgfx::isTextureValid(0, false, 1, depthStencilFormat, BGFX_TEXTURE_RT));

            std::array<bgfx::TextureHandle, 2> textures{
                bgfx::createTexture2D(width, height, generateMips, 1, format, BGFX_TEXTURE_RT),
                bgfx::createTexture2D(width, height, generateMips, 1, depthStencilFormat, BGFX_TEXTURE_RT)};
            std::array<bgfx::Attachment, textures.size()> attachments{};
            for (size_t idx = 0; idx < attachments.size(); ++idx)
            {
                attachments[idx].init(textures[idx]);
            }
            frameBufferHandle = bgfx::createFrameBuffer(static_cast<uint8_t>(attachments.size()), attachments.data(), true);
        }

        texture->Handle = bgfx::getTexture(frameBufferHandle);
        return Napi::External<FrameBufferData>::New(info.Env(), m_frameBufferManager.CreateNew(frameBufferHandle, width, height));
    }

    void NativeEngine::DeleteFrameBuffer(const Napi::CallbackInfo& info)
    {
        // Check if this native frame buffer is marked as owned by JavaScript.  It's possible that
        // we do not recognize it as having been passed back to JS in which case BabylonNative should be
        // responsible for deleting this frame buffer instead.
        const auto frameBufferData = info[0].As<Napi::External<FrameBufferData>>().Data();
        if (frameBufferData->OwnedByJS)
        {
            delete frameBufferData;
        }
    }

    void NativeEngine::BindFrameBuffer(const Napi::CallbackInfo& info)
    {
        const auto frameBufferData = info[0].As<Napi::External<FrameBufferData>>().Data();
        m_frameBufferManager.Bind(frameBufferData);
    }

    void NativeEngine::UnbindFrameBuffer(const Napi::CallbackInfo& info)
    {
        const auto frameBufferData = info[0].As<Napi::External<FrameBufferData>>().Data();
        m_frameBufferManager.Unbind(frameBufferData);
    }

    void NativeEngine::DrawIndexed(const Napi::CallbackInfo& info)
    {
        const auto fillMode = info[0].As<Napi::Number>().Int32Value();
        const auto elementStart = info[1].As<Napi::Number>().Int32Value();
        const auto elementCount = info[2].As<Napi::Number>().Int32Value();
        // TODO: handle viewport

        if (m_currentBoundIndexBuffer)
        {
            m_currentBoundIndexBuffer->SetBgfxIndexBuffer(elementStart, elementCount);
        }

        // TODO: support other fill modes
        uint64_t fillModeState = 0; //indexed tri list
        switch (fillMode)
        {
            case 2: // MATERIAL_PointFillMode
                fillModeState = BGFX_STATE_PT_POINTS;
                break;
            case 4: // MATERIAL_LineListDrawMode
                fillModeState = BGFX_STATE_PT_LINES;
                break;
            case 6: // MATERIAL_LineStripDrawMode
                fillModeState = BGFX_STATE_PT_LINESTRIP;
                break;
            case 7: // MATERIAL_TriangleStripDrawMode
                fillModeState = BGFX_STATE_PT_TRISTRIP;
                break;
        }

        if (m_frameBufferManager.IsRenderingToTarget() && (!bgfx::getCaps()->originBottomLeft))
        {
            // UV coordinates system are different between OpenGL and Direct3D/Metal
            // This is not an issue with loaded textures (png/jpg...) because
            // texel rows bytes are also using a different convention
            // see https://www.puredevsoftware.com/blog/2018/03/17/texture-coordinates-d3d-vs-opengl/
            // for render to texture, as the texel bytes are not reversed, sampling a RTT for
            // post process or shadows will result in inversion on V axis (Y)
            // to compensate for that, any matrix that is used to project onto clip-space has
            // to be flipped.
            // The involved matrices are determined by name and a boolean YFlip is set to true.
            // When rendering to texture, those matrices are flipped and set as uniform datas.
            // But because flipping clip-space coordinates also flips triangles winding,
            // Culling also has to be flipped.
            for (const auto& it : m_currentProgram->Uniforms)
            {
                const ProgramData::UniformValue& value = it.second;
                if (value.YFlip)
                {
                    float tmpMatrix[16];
                    static const float flipMatrix[16] = {1.f, 0.f, 0.f, 0.f,
                        0.f, -1.f, 0.f, 0.f,
                        0.f, 0.f, 1.f, 0.f,
                        0.f, 0.f, 0.f, 1.f};
                    bx::mtxMul(tmpMatrix, value.Data.data(), flipMatrix);
                    bgfx::setUniform({it.first}, tmpMatrix, value.ElementLength);
                }
                else
                {
                    bgfx::setUniform({it.first}, value.Data.data(), value.ElementLength);
                }
            }

            // We need to explicitly swap the culling state flags (instead of XOR)
            // because we would like to preserve the no culling configuration, which is 00.
            const auto cullCW = (m_engineState & BGFX_STATE_CULL_CCW) != 0 ? BGFX_STATE_CULL_CW : 0;
            const auto cullCCW = (m_engineState & BGFX_STATE_CULL_CW) != 0 ? BGFX_STATE_CULL_CCW : 0;

            uint64_t m_engineStateYFlipped = m_engineState;
            m_engineStateYFlipped &= ~BGFX_STATE_CULL_MASK;
            m_engineStateYFlipped |= (cullCW | cullCCW) << BGFX_STATE_CULL_SHIFT;

            bgfx::setState(m_engineStateYFlipped | fillModeState);
        }
        else
        {
            for (const auto& it : m_currentProgram->Uniforms)
            {
                const ProgramData::UniformValue& value = it.second;
                bgfx::setUniform({it.first}, value.Data.data(), value.ElementLength);
            }
            bgfx::setState(m_engineState | fillModeState);
        }

        bgfx::submit(m_frameBufferManager.GetBound().ViewId, m_currentProgram->Program, 0, BGFX_DISCARD_INSTANCE_DATA | BGFX_DISCARD_STATE | BGFX_DISCARD_TRANSFORM);
    }

    void NativeEngine::Draw(const Napi::CallbackInfo& info)
    {
        bgfx::discard(BGFX_DISCARD_INDEX_BUFFER);
        m_currentBoundIndexBuffer = nullptr;
        DrawIndexed(info);
    }

    void NativeEngine::Clear(const Napi::CallbackInfo& info)
    {
        FrameBufferData& frameBufferData{m_frameBufferManager.GetBound()};
        frameBufferData.UseViewId(m_frameBufferManager.GetNewViewId());

        ViewClearState& viewClearState{frameBufferData.ViewClearState};
        uint16_t flags{0};

        if (info[0].IsObject())
        {
            const auto color{info[0].As<Napi::Object>()};
            const auto r = color.Get(""r"");
            const auto g = color.Get(""g"");
            const auto b = color.Get(""b"");
            const auto a = color.Get(""a"");

            viewClearState.UpdateColor(
                r.As<Napi::Number>().FloatValue(),
                g.As<Napi::Number>().FloatValue(),
                b.As<Napi::Number>().FloatValue(),
                a.IsUndefined() ? 1.f : a.As<Napi::Number>().FloatValue());

            flags |= BGFX_CLEAR_COLOR;
        }

        if (info[1].IsNumber())
        {
            viewClearState.UpdateDepth(info[1].As<Napi::Number>().FloatValue());
            flags |= BGFX_CLEAR_DEPTH;
        }

        if (info[2].IsNumber())
        {
            viewClearState.UpdateStencil(static_cast<uint8_t>(info[2].As<Napi::Number>().Uint32Value()));
            flags |= BGFX_CLEAR_STENCIL;
        }

        viewClearState.UpdateFlags(flags);
    }

    Napi::Value NativeEngine::GetRenderWidth(const Napi::CallbackInfo& info)
    {
        return Napi::Value::From(info.Env(), bgfx::getStats()->width);
    }

    Napi::Value NativeEngine::GetRenderHeight(const Napi::CallbackInfo& info)
    {
        return Napi::Value::From(info.Env(), bgfx::getStats()->height);
    }

    void NativeEngine::SetViewPort(const Napi::CallbackInfo& info)
    {
        const auto x = info[0].As<Napi::Number>().FloatValue();
        const auto y = info[1].As<Napi::Number>().FloatValue();
        const auto width = info[2].As<Napi::Number>().FloatValue();
        const auto height = info[3].As<Napi::Number>().FloatValue();
        const float yOrigin = bgfx::getCaps()->originBottomLeft ? y : (1.f - y - height);

        m_frameBufferManager.GetBound().SetViewPort(x, yOrigin, width, height);
    }

    void NativeEngine::GetFramebufferData(const Napi::CallbackInfo& info)
    {
        bgfx::FrameBufferHandle fbh = BGFX_INVALID_HANDLE;
        const auto callback = info[0].As<Napi::Function>();

        m_graphicsImpl.Callback.addScreenShotCallback(callback);
        bgfx::requestScreenShot(fbh, ""GetImageData"");
    }

    Napi::Value NativeEngine::GetRenderAPI(const Napi::CallbackInfo& info)
    {
        return Napi::Value::From(info.Env(), static_cast<int>(bgfx::getRendererType()));
    }

    void NativeEngine::Dispatch(std::function<void()> function)
    {
        m_runtime.Dispatch([function = std::move(function)](Napi::Env) {
            function();
        });
    }

    void NativeEngine::SetHardwareScalingLevel(const Napi::CallbackInfo& info)
    {
        const auto level = info[0].As<Napi::Number>().FloatValue();
        m_graphicsImpl.SetHardwareScalingLevel(level);
    }

    Napi::Value NativeEngine::GetHardwareScalingLevel(const Napi::CallbackInfo& info)
    {
        return Napi::Value::From(info.Env(), m_graphicsImpl.GetHardwareScalingLevel());
    }
}
",16291,True,3097.9246633598686,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.
////
= For Committers

image::business-gremlin.png[width=400]

The guidelines that follow generally apply to those with commit access to the main repository, but those seeking to
contribute will also find helpful information here on the development style and process for the project.

[[initial-setup]]
== Initial Setup

Once the Apache TinkerPop PMC has sent an invitation to a contributor to become a new committer and that contributor
has accepted that invitation and provided their iCLA to Apache, then there are some administrative steps that the
new committer can expect to go through to complete the process so that they have access to Apache resources like the
Git repository. While the information for completing the process can be found in a multitude of places the following
listing provides a summary of what to do next:

* Look for a welcome email from root_at_apache.org. This will contain your Apache user name
** e.g. ""Welcome to the Apache Software Foundation (ASF)!""
* Visit https://id.apache.org/reset/enter and enter your user name
* Look for a password reset email from root_at_apache.org. This will have been sent after you confirmed your user name, above.
** e.g. ""Password reset request for [username] from Apache ID""
* Visit the link provided in the password reset email, and choose a new password. ASF asks you to choose a strong one. You will see a ""Password change successful"" page when this is done.
* You will now have SVN access
** link:https://svn.apache.org/[svn.apache.org]
* Try sending yourself an email at your new [username]@apache.org email address. It should forward to your primary address.
* Check your account details at https://id.apache.org/details/[username]
* Link your accounts using gitbox (https://gitbox.apache.org/setup/)
** Link your Apache account
** Link your GitHub account
*** You will be asked to ""Authorize Apache M.A.T.T.""
** Obtain MFA status
*** Visit link:https://id.apache.org[id.apache.org] and set your GitHub ID to be invited to the org
*** Wait for an email to arrive from ""support_at_github.com"", and click ""Join @apache"". Accept the invitation on github.com. Your new MFA status will not immediately be reflected on github, but you will get a confirmation email from noreply_at_github.com. Later, the status will read ""MFA ENABLED""
**** e.g. ""[GitHub] @asf-gitbox has invited you to join the @apache organization""
*** You can find yourself by searching in the link:https://github.com/orgs/apache/teams/apache-committers[Apache Committers listing]
* Read the link:https://www.apache.org/dev/new-committers-guide.html[Apache Committer Guide] and link:http://www.apache.org/dev/committers.html[Apache Committer FAQ]
* Read through the other sections of this document - the Developer Documentation - for more details on project procedures and other administrative items.
** In particular, see <<rtc,Review then Commit>>
* If you have trouble committing, email dev@tinkerpop.apache.org

== Communication

TinkerPop has a link:http://groups.google.com/group/gremlin-users[user mailing list] and a
pass:[<a href=""https://lists.apache.org/list.html?dev@tinkerpop.apache.org"">dev mailing list</a>].  As a committer,
it is a good idea to join both.

TinkerPop also has a link:https://the-asf.slack.com/archives/CUBJ577EW[Slack channel] for more real-time communication
about the project among contributors, though it must be kept in mind that project discussion and decisions must occur
on the dev mailing list mentioned above.

Occasionally, online meetings via video conference are held. These meetings are schedule via the dev mailing list
about a week before they are to occur to find a day and time that is available for those interested in attending.
On the day of the meeting, the meeting organizer will create a Google Hangout (or similar video conferencing link).
At that point, all who are interested can attend.  Meeting minutes should be
taken and added to the <<meetings,Meetings>> section of this document using the pattern already established.

== Release Notes

There is a two-pronged approach to maintaining the change log and preparing the release notes.

1. For work that is documented in JIRA, run the release notes report to include all of
the tickets targeted for a specific release.  This report can be included in the
release announcement.

2. The manual change log (`CHANGELOG.asciidoc`) can be used to highlight large
changes, describe themes (e.g. ""We focused on performance improvements"") or to
give voice to undocumented changes.

Given the dependence on the JIRA report for generating additions to the `CHANGELOG.asciidoc`,
which uses the title of the issue as the line presented in the release note report, titles should
be edited prior to release to be useful in that context.  In other words, an issue title should
be understandable as a change in the fewest words possible while still conveying the gist of the
change.

Changes that break the public APIs should be marked with a ""breaking"" label and should be
distinguished from other changes in the release notes.

[[branches]]
== Branches

TinkerPop has several release branches:

* `3.0-dev` - 3.0.x (no longer maintained)
* `3.1-dev` - 3.1.x (no longer maintained)
* `3.2-dev` - 3.2.x (no longer maintained)
* `3.3-dev` - 3.3.x (no longer maintained)
* `3.4-dev` - 3.4.x (bug fixes and minor non-breaking enhancements)
* `master` - 3.5.x (future development)
* `4.0-dev` - 4.0.x (future development)

Changes to earlier branches should merge forward toward `master` (e.g. `3.4-dev` should merge to `master`). Please read
more about this process in the <<pull-requests, Pull Requests>> section. Note that `4.0-dev` is rebased on `master`
and currently behaves as a fresh repository as all 3.x content was removed.

Other branches may be created for collaborating on features or for RFC's that other developers may want to inspect.
It is suggested that the JIRA issue ID be used as the prefix, since that triggers certain automation, and it provides a
way to account for the branch lifecycle, i.e. ""Who's branch is this, and can I delete it?""

For branches that are NOT associated with JIRA issues, developers should utilize their Apache ID as
a branch name prefix.  This provides a unique namespace, and also a way to account for the branch lifecycle.

Developers should remove their own branches when they are no longer needed.

== Tags

Tags are used for milestones, release candidates, and approved releases.  Please refrain from creating arbitrary
tags, as they produce permanent clutter.

== Issue Tracker Conventions

TinkerPop uses Apache JIRA as its link:https://issues.apache.org/jira/browse/TINKERPOP[issue tracker].  JIRA is a
very robust piece of software with many options and configurations.  To simplify usage and ensure consistency across
issues, the following conventions should be adhered to:

* An issue's ""status"" should generally be in one of two states: `open` or `closed` (`reopened` is equivalent to `open`
for our purposes).
** An `open` issue is newly created, under consideration or otherwise in progress.
** A `closed` issue is completed for purposes of release (i.e. code, testing, and documentation complete).
** Issues in a `resolved` state should immediately be evaluated for movement to `closed` - issue become `resolved`
by those who don't have the permissions to `close`.
* An issue's ""type"" should be one of two options: `bug` or `improvement`.
** A `bug` has a very specific meaning, referring to an error that prevents usage of TinkerPop AND does not have a
reasonable workaround.  Given that definition, a `bug` should generally have very high priority for a fix.
** Everything else is an `improvement` in the sense that any other work is an enhancement to the current codebase.
* The ""component"" should be representative of the primary area of code that it applies to and all issues should have
this property set.
* Issues are not assigned ""labels"" with two exceptions:
** The ""breaking"" label which marks an issue as one that is representative of a change in the API that might
affect users or providers.  This label is important when organizing release notes.
** The ""deprecation"" label which is assigned to an issue that includes changes to deprecate a portion of the API.
* The ""affects/fix version(s)"" fields should be appropriately set, where the ""fix version"" implies the version on
which that particular issue will completed. This is a field usually only set by committers.
* The ""priority"" field can be arbitrarily applied with one exception.  The ""trivial"" option should be reserved for
tasks that are ""easy"" for a potential new contributor to jump into and do not have significant impact to urgently
required improvements.
* The ""resolution"" field which is set on the close of the issue should specify the status most closely related to why
the issue was closed. In most cases, this will mean ""Fixed"" for a ""Bug"" or ""Done"" for an ""Improvement"". Only one
resolution has special meaning and care should be taken with this particular option: ""Later"". ""Later"" means that the
item is a good idea but likely will not be implemented in any foreseeable future. By closing uncompleted issues with
this resolution, it should be easy to come back to them later when needed.

== Code Style

Contributors should examine the current code base to determine what the code style patterns are and should match their
style to what is already present. Of specific note however, TinkerPop does not use ""import wildcards"" - IDEs should
be adjusted accordingly to not auto-wildcard the imports.

== Build Server

TinkerPop uses link:https://travis-ci.com/[Travis] for link:https://en.wikipedia.org/wiki/Continuous_integration[CI]
services. The build status can be found link:https://travis-ci.org/apache/tinkerpop[here].  Note that the CI process
does not run all possible tests (e.g. Neo4j-related tests) as a full execution would likely exceed the allowable times
for builds on these servers. Instead Travis runs a basic cross-section of tests selected to provide a reasonably high
degree of confidence in the branch built.

== Deprecation

When possible, committers should avoid direct ""breaking"" change (e.g. removing a method from a class) and favor
deprecation.  Deprecation should come with sufficient documentation and notice especially when the change involves
public APIs that might be utilized by users or implemented by providers:

* Mark the code with the `@Deprecated` annotation.
* Use javadoc to further document the change with the following content:
** `@deprecated As of release x.y.z, replaced by {@link SomeOtherClass#someNewMethod()}` - if the method is not
replaced then the comment can simply read ""not replaced"".  Additional comments that provide more context are
encouraged.
** `@see <a href=""https://issues.apache.org/jira/browse/TINKERPOP-XXX"">TINKERPOP-XXX</a>` - supply a link to the
JIRA issue for reference - the issue should include the ""deprecation"" label.
* Be sure that deprecated methods are still under test - consider using javadoc/comments in the tests themselves to
call out this fact.
* Create a new JIRA issue to track removal of the deprecation for future evaluation.
* Update the ""upgrade documentation"" to reflect the API change and how the reader should resolve it.

The JIRA issues that track removal of deprecated methods should be periodically evaluated to determine if it is
prudent to schedule them into a release.

== Developing Tests

TinkerPop has a wide variety of test types that help validate its internal code as well as external provider code.
There are ""unit tests"" and ""integration tests"". Unit tests execute on standard runs of `mvn clean install`.  These
tests tend to run quickly and provide a reasonable level of coverage and confidence in the code base.  Integration
tests are disabled by default and must be explicitly turned on with a special build property by adding
`-DskipIntegrationTests=false` to the `mvn` execution.  Integration tests run slower and may require external
components to be running when they are executed. They are ""marked"" as separate from unit tests by inclusion of the
suffix ""IntegrateTest"".

Here are some other points to consider when developing tests:

* Avoid use of `println` in tests and prefer use of a SLF4j `Logger` instance so that outputs can be controlled in a
standard way.
* If it is necessary to create files on the filesystem, do not hardcode directories - instead, use the `TestHelper` to
create directory structures.  `TestHelper` will properly create file system structure in the appropriate build
directory thus allowing proper clean-up between test runs.
* If writing tests in one of the test suites, like `gremlin-test`, it is important to remember that if a new `Graph`
instance is constructed within the test manually, that it be closed on exit of that test.  Failing to do this cleanup
can cause problems for some graph providers.
* Tests that are designed to use a `GraphProvider` implementation in conjunction with `AbstractGremlinTest` _and_ are
in the `/test` directory should not be named with `Test` as the suffix, as this will cause them to execute in some
environments without a `GraphProvider` being initialized by a suite. These types of tests should be suffixed with
`Check` instead. Please see link:https://github.com/apache/tinkerpop/blob/e32a4187e4f25e290aabe14007f9087c48a06521/neo4j-gremlin/src/test/java/org/apache/tinkerpop/gremlin/neo4j/structure/NativeNeo4jStructureCheck.java[NativeNeo4jStructureCheck]
for an example.

=== Gremlin Language Test Cases

Test cases for the Gremlin Language currently requires that the newly developed test be added in three places:

1. As a test written in Java in the `gremlin-test` module within the subpackages of
`org.apache.tinkerpop.gremlin.process.traversal.step`
2. As a test written in Gherkin in the `gremlin-test` module in the `/features` subdirectory

When writing a Java test case for a Gremlin step, be sure to use the following conventions.

* The name of the traversal generator should start with `get`, use `X` for brackets, `_` for space, and the Gremlin-Groovy sugar syntax.
** `get_g_V_hasLabelXpersonX_groupXaX_byXageX_byXsumX_name()`
* When creating a test for a step that has both a barrier and sideEffect form (e.g. `group()`, `groupCount()`, etc.), test both representations.
** `get_g_V_groupCount_byXnameX()`
** `get_g_V_groupCountXaX_byXnameX_capXaX()`
* The name of the actual test case should be the name of the traversal generator minus the `get_` prefix.
* The Gremlin-Groovy version of the test should use the sugar syntax in order to test sugar (as Gremlin-Java tests test standard syntax).
** `g.V.age.sum`
* Avoid using lambdas in the test case unless that is explicitly what is being tested as OLAP systems will typically not be able to execute those tests.
* `AbstractGremlinProcessTest` has various static methods to make writing a test case easy.
** `checkResults(Arrays.asList(""marko"",""josh""), traversal)`
** `checkMap(new HashMap<String,Long>() {{ put(""marko"",1l); }}, traversal.next())`

Gherkin tests follow some important conventions and have a sub-language that must be adhered to for the tests to
function properly. Note that Gherkin tests are designed to support the testing of GLVs and at some point will likely
replace the Java tests. If a new Java test is added and an associated Gherkin tests is not, the overall build will
fail the `FeatureCoverageTest` of `gremlin-test` which validates that all tests written in Java are also implemented
in Gherkin.

The basic syntax of a Gherkin test is as follows:

[source,gherkin]
----
Scenario: g_VX1X_unionXrepeatXoutX_timesX2X__outX_name
  Given the modern graph
  And using the parameter vId1 defined as ""v[marko].id""
  And the traversal of
    """"""
    g.V(vId1).union(__.repeat(__.out()).times(2), __.out()).values(""name"")
    """"""
  When iterated to list
  Then the result should be unordered
    | result |
    | ripple |
    | lop |
    | lop   |
    | vadas |
    | josh  |
----

==== Scenario Name

The name of the scenario needs to match the name of the Java test. If it does not then the `FeatureCoverageTest` will
fail.

==== Given

""Given"" sets the context of the test. Specifically, it establishes the graph that will be used for the test. It
conforms to the pattern of ""Given the _xxx_ graph"" where the ""xxx"" may be one of the following:

* empty
* modern
* classic
* crew
* sink
* grateful

Never modify the data of any of the graphs except for the ""empty"" graph. The ""empty"" graph is the only graph that is
guaranteed to be refreshed between tests. The ""empty"" graph maybe be modified by the traversal under test or by an
additional ""Given"" option:

[source,gherkin]
----
Given the empty graph
And the graph initializer of
  """"""
  g.addV(""person"").property(T.id, 1).property(""name"", ""marko"").property(""age"", 29).as(""marko"").
    addV(""person"").property(T.id, 2).property(""name"", ""vadas"").property(""age"", 27).as(""vadas"").
    addV(""software"").property(T.id, 3).property(""name"", ""lop"").property(""lang"", ""java"").as(""lop"").
    addV(""person"").property(T.id, 4).property(""name"",""josh"").property(""age"", 32).as(""josh"").
    addV(""software"").property(T.id, 5).property(""name"", ""ripple"").property(""lang"", ""java"").as(""ripple"").
    addV(""person"").property(T.id, 6).property(""name"", ""peter"").property(""age"", 35).as('peter').
    addE(""knows"").from(""marko"").to(""vadas"").property(T.id, 7).property(""weight"", 0.5).
    addE(""knows"").from(""marko"").to(""josh"").property(T.id, 8).property(""weight"", 1.0).
    addE(""created"").from(""marko"").to(""lop"").property(T.id, 9).property(""weight"", 0.4).
    addE(""created"").from(""josh"").to(""ripple"").property(T.id, 10).property(""weight"", 1.0).
    addE(""created"").from(""josh"").to(""lop"").property(T.id, 11).property(""weight"", 0.4).
    addE(""created"").from(""peter"").to(""lop"").property(T.id, 12).property(""weight"", 0.2)
  """"""
----

The above configuration will use the ""empty"" graph and initialize it with the specified traversal. In this case, that
traversal loads the ""empty"" graph with the ""modern"" graph.

Once the graph for the test is defined, the context can be expanded to include parameters that will be applied to the
traversal under test. Any variable value being used in the traversal under test, especially ones that require a
specific type, should be defined as parameters. The structure for parameter definition looks like this:

[source,gherkin]
----
Given the modern graph
And using the parameter vId1 defined as ""v[marko].id""
----

In the above example, ""vId1"" is the name of the parameter that will be used in the traversal. The end of that line in
quotes is the value of that parameter and should use the type system notation that has been developed for the TinkerPop
Gherkin tests. The type system notation ensures that different language variants have the ability to construct the
appropriate types expected by the tests.

The syntax of the type notation involves a prefix character to help denote the type, a value between two square
brackets, optionally suffixed with some additional notation depending on the primary type.

* Edge - *e[_xxx_]* - The ""xxx"" should be replaced with a representation of an edge in the form of the
`vertex_name-edgelabel->vertex_name`. This syntax may also include the `.id` suffix which would indicate getting the
edge identifier or the `.sid` suffix which gets a string representation of the edge identifier.
* Lambda - *c[_xxx_]* - The ""xxx"" should contain a lambda written in Groovy.
* List - *l[_xxx_,_yyy_,_zzz_,...]* - A comma separated collection of values that make up the list should be added to
between the square brackets. These values respect the type system thus allowing for creation of lists of vertices,
edges, maps, and any other available type.
* Map - *m[_xxx_]* - The ""xxx"" should be replaced with a JSON string. Note that keys and values will be parsed using
the type notation system so that it is possible to have maps containing arbitrary keys and values.
* Numeric - *d[_xxx_]._y_* - The ""xxx"" should be replaced with a number. The suffix denoted by ""y"" should always be
included to further qualify the type of numeric. The following options are available:
** *d* - 32-bit Double
** *f* - 32-bit Float
** *i* - 32-bit Integer
** *l* - 64-bit Long
** *m* - Arbitrary-precision signed decimal numbers (i.e. BigDecimal in Java)
* Path - *p[_xxx_,_yyy_,_zzz_,...]* - A comma separated collection of values that make up the `Path` should be added to
between the square brackets. These values respect the type system thus allowing for creation of `Path` of vertices,
edges, maps, and any other available type.
* Set - *s[_xxx_,_yyy_,_zzz_,...]* - A comma separated collection of values that make up the set should be added to
between the square brackets. These values respect the type system thus allowing for creation of sets of vertices,
edges, maps, and any other available type.
* String - Any value not using the system notation will be interpreted as a string.
* T - *t[_xxx_]* - The ""xxx"" should be replaced with a value of the `T` enum, such as `id` or `label`.
* Vertex - *v[_xxx_]* - The ""xxx"" should be replaced with the ""name"" property of a vertex in the graph. This syntax may
include the `.id` suffix which would indicate getting the vertex identifier or the `.sid` suffix which gets a string
representation of the edge identifier.

In addition, parameter names should adhere to a common form as they hold some meaning to certain language variant
implementations:

* General variables of no particular type should use `xx1`, `xx2` and `xx3`.
* A `Vertex` variable should be prefixed with ""v"" and be followed by the `id`, therefore, `v1` would signify a `Vertex`
with the `id` of ""1"".
* An `Edge` variable follows the pattern of vertices but with a ""e"" prefix.
* The ""id"" of a `Vertex` or `Edge` is prefixed with ""vid""`"" or ""eid"" respectively followed by the `id`, thus, `vid1`
would be ""1"" and refer to the `Vertex` with that `id`.
* `Function` variables should use `l1` and `l2`.
* `Predicate` variables should use `pred1`.
* `Comparator` variables should use `c1` and `c2`.    

Finally, specify the traversal under test with the ""Given"" option ""and the traversal"":

[source,gherkin]
----
And the traversal of
  """"""
  g.V(vId1).union(__.repeat(__.out()).times(2), __.out()).values(""name"")
  """"""
----

It will be the results of this traversal that end up being asserted by Gherkin. When writing these test traversals,
be sure to always use the method and enum prefixes. For example, use  `__.out()` for an anonymous traversal rather
than just `out()` and prefer `Scope.local` rather than just `local`.

If a particular test cannot be written in Gherkin for some reason or cannot be otherwise supported by a GLV, first,
consider whether or not this test can be re-written in Java so that it will work for GLVs and then, second, if it
cannot, then use the following syntax for unsupported tests:

[source,gherkin]
----
Scenario: g_V_outXcreatedX_groupCountXxX_capXxX
  Given an unsupported test
  Then nothing should happen because
    """"""
    The result returned is not supported under GraphSON 2.x and therefore cannot be properly asserted. More
    specifically it has vertex keys which basically get toString()'d under GraphSON 2.x. This test can be supported
    with GraphSON 3.x.
    """"""
----

==== When

The ""When"" options get the result from the traversal in preparation for assertion. There are two options to iterate:

* ""When iterated to list"" - iterates the entire traversal into a list result that is asserted
* ""When iterated next"" - gets the first value from the traversal as the result to be asserted

There should be only one ""When"" defined in a scenario.

==== Then

The ""Then"" options handle the assertion of the result. There are several options to consider:

* ""the result should have a count of _xxx_"" - assumes a list value in the result and counts the number of values
in it
* ""the result should be empty"" - no results
* ""the result should be ordered"" - the exact results and should appear in the order presented
* ""the result should be unordered"" - the exact results but can appear any order
* ""the result should be of"" - results can be any of the specified values and in any order (use when guarantees
regarding the exact results cannot be pre-determined easily - see the `range()`-step tests for examples)

These final three types of assertions mentioned above should be followed by a Gherkin table that has one column, where
each row value in that column represents a value to assert in the result. These values are type notation respected as
shown in the following example:

[source,gherkin]
----
Then the result should be unordered
  | result |
  | ripple |
  | lop |
  | lop   |
  | vadas |
  | josh  |
----

Another method of assertion is to test mutations in the original graph. Again, mutations should only occur on the
""empty"" graph, but they can be validated as follows:

[source,gherkin]
----
Scenario: g_V_outE_drop
  Given the empty graph
  And the graph initializer of
    """"""
    g.addV().as(""a"").addV().as(""b"").addE(""knows"").to(""a"")
    """"""
  And the traversal of
    """"""
    g.V().outE().drop()
    """"""
  When iterated to list
  Then the result should be empty
  And the graph should return 2 for count of ""g.V()""
  And the graph should return 0 for count of ""g.E()""
----

== Developing Benchmarks

Benchmarks are a useful tool to track performance between TinkerPop versions and also as tools to aid development
decision making. TinkerPop uses link:http://openjdk.java.net/projects/code-tools/jmh/[OpenJDK JMH] for benchmark development.
The JMH framework provides tools for writing robust benchmarking code that avoid many of the pitfalls inherent in benchmarking
JIT compiled code on the JVM.  Example JMH benchmarks can be found
link:http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/[here].

TinkerPop benchmarks live in the `gremlin-benchmark` module and can either be run from within your IDE or as a standalone
uber-jar.  The uber-jar is the JMH recommended approach and also makes it easy to distribute artifacts to various environments
to gather benchmarking numbers.  Having said that, in most cases it should be sufficient to run it from within the IDE.

Benchmarks will not run by default because they are time consuming.  To enable benchmarks during the test phase do
`-DskipBenchmarks=false`.  To change the number of warmup iterations, measurement iterations, and forks you can do
`mvn clean test -DskipBenchmarks=false -DdefaultForks=5 -DmeasureIterations=20 -DwarmupIterations=20`.  Benchmark results
will be output by default to the `benchmarks` directory in JSON format.

Benchmarks may also be run from the command line using the JMH runner.  Build the uber-jar and simply run
`java -jar gremlin-benchmark-TP-VERSION.jar`.  To see a list of JMH runner options, add the `-h` flag.

The JUnit/JMH integration was inspired by the Netty projects microbenchmarking suite.  Please refer to the Netty
link:http://netty.io/wiki/microbenchmarks.html[docs] for more details.  Presently there are 3 abstract benchmark classes
that may be used as building blocks for your benchmarks; `AbstractBenchmarkBase`, `AbstractGraphBenchmark`, and
`AbstractGraphMutateBenchmark`.

* `AbstractBenchmarkBase` - extend when your benchmark does not require a graph instance
* `AbstractGraphBenchmark` - extend when you are benchmarking read operations against a graph
* `AbstractGraphMutateBenchmark` - extend when you are benchmarking graph mutation operations eg. `g.addV()`, `graph.addVertex()`

[[rtc]]
== Review then Commit

Code modifications must go through a link:http://www.apache.org/foundation/glossary.html#ReviewThenCommit[review-then-commit] (RTC)
process before being merged into a release branch. All committers should follow the pattern below, where ""you"" refers
to the committer wanting to put code into a release branch.

* Make a JIRA ticket for the software problem you want to solve (i.e. a fix).
* Fork the release branch that the fix will be put into.
** The branch name should be the JIRA issue identifier (e.g. `TINKERPOP-XXX`).
* Develop your fix in your branch.
* When your fix is complete and ready to merge, issue a <<pull-requests,pull request>>.
** Be certain that the test suite is passing.
** If you updated documentation, be sure that the `process-docs.sh` is building the documentation correctly.
* Before you can merge your branch into the release branch, you must have at least 3 +1 link:http://www.apache.org/foundation/glossary.html#ConsensusApproval[consensus votes]
from other committers OR a single +1 from a committer and a seven day review period for objections (i.e. a ""cool down
period"") at which point we will assume a lazy consensus.
** Please see the Apache Software Foundations regulations regarding link:http://www.apache.org/foundation/voting.html#votes-on-code-modification[Voting on Code Modifications].
** With the ""cool down"" process and lazy consensus the single +1 may (should) come from the committer who submitted
the pull request (in other words, the change submitter and the reviewer are the same person).
** Committers are trusted with their changes, but are expected to request reviews for complex changes as necessary and
not rely strictly on lazy consensus.
* Votes are issued by TinkerPop committers as comments to the pull request.
* Once either consensus position is reached, you are responsible for merging to the release branch and handling any merge conflicts.
** If there is a higher version release branch that requires your fix (e.g. `3.y-1.z` fix going to a `3.y.z` release), multiple pull requests may be necessary (i.e. one for each branch).
* Be conscious of deleting your branch if it is no longer going to be used so stale branches don't pollute the repository.

NOTE: These steps also generally apply to external pull requests from those who are not official Apache committers. In
this case, the person responsible for the merge after voting is typically the first person available
who is knowledgeable in the area that the pull request affects. Any additional coordination on merging can be handled
via the pull request comment system.

For those performing reviews as part of this process it is worth noting that the notion of ""review"" is fairly wide for
our purposes. TinkerPop has grown into a large and complex code base and very few people (if anyone) is knowledgeable
on all of its modules. Detailed code reviews might often be difficult or impossible as a result.

To be clear, a ""review"" need not be specifically about the exact nature of the code. It is perfectly reasonable to
review (and VOTE) in the following fashion:

* VOTE +1 - ran docker integration tests and everything passes
* VOTE +1 - reviewed the code in detail - solid pull request
* VOTE +1 - agree with the principle of this pull request but don't fully understand the code
* VOTE +1 - read through the updated documentation and understand why this is important, nice

Non-committers are welcome to review and VOTE as well and while their VOTEs are not binding, they will be taken as
seriously as non-binding VOTEs on releases. Reviewing and VOTEing on pull requests as a non-committer is a great way
to contribute to the TinkerPop community and get a good pulse on the changes that are upcoming to the framework.

The following exceptions to the RTC (review-then-commit) model presented above are itemized below. It is up to the
committer to self-regulate as the itemization below is not complete and only hints at the types of commits that do not
require a review.

* You are responsible for a release and need to manipulate files accordingly for the release.
** `Gremlin.version()`, CHANGELOG dates, `pom.xml` version bumps, etc.
* You are doing an minor change and it is obvious that an RTC is not required (would be a pointless burden to the community).
** The fix is under the link:http://www.apache.org/foundation/glossary.html#CommitThenReview[commit-then-review] (CTR) policy and lazy consensus is sufficient, where a single -1 vote requires you to revert your changes.
** Adding a test case, fixing spelling/grammar mistakes in the documentation, fixing LICENSE/NOTICE/etc. files, fixing a minor issue in an already merged branch.

When the committer chooses CTR, it is considered good form to include something in the commit message that explains
that CTR was invoked and the reason for doing so.  For example, ""Invoking CTR as this change encompasses minor
adjustments to text formatting."" CTR based commits will still require manual merging through all release branches.
Merges should occur in reverse order, starting with the latest release version first (e.g. if the fix is going to
3.3.x then the change should be merged in the following order `master`, `3.4-dev`, `3.3-dev`).

[[pull-requests]]
=== Pull Requests

When submitting a pull request to one of the <<branches, release branches>>, be sure it uses the following style:

* The title of the pull request is the JIRA ticket number + ""colon"" + the title of the JIRA ticket.
* The first line of the pull request message should contain a link to the JIRA ticket.
* Discuss what you did to solve the problem articulated in the JIRA ticket.
* Discuss any ""extra"" work done that go beyond the assumed requirements of the JIRA ticket.
* Be sure to explain what you did to prove that the issue is resolved.
** Test cases written.
** Integration tests run (if required for the work accomplished).
** Documentation building (if required for the work accomplished).
** Any manual testing (though this should be embodied in a test case).
* Notes about what you will do when you merge to the respective release branch (e.g. update CHANGELOG).
** These types of ""on merge tweaks"" are typically done to extremely dynamic files to combat and merge conflicts.
* If you are a TinkerPop committer, you can VOTE on your own pull request, so please do so.

A pull request will typically be made to a target <<branches, branch>>. Assuming that branch is upstream of other
release branches (e.g. a pull request made to for the branch containing 3.3.x must merge to the branch that releases
3.4.x), it is important to be sure that those changes are merged to the downstream release branches. If the merge from
one release branch to another is not terribly conflicted, it is likely safe to offer a single pull request and then
merge through the release branches after review. If there is conflict or the likelihood of test failures in downstream
branches then this process is best handled by multiple pull requests: one to each release branch. Release branches with
merged changes should be pushed in reverse order, starting with the latest release version first (e.g. if the fix is
going to 3.3.x then the change should be merged in the following order: `master`, 3.4-dev`, `3.3-dev`).

As an example, consider a situation where there is a feature branch named ""TINKERPOP-1234"" that contains a fix for
the `3.4-dev` branch:

[source,bash]
----
`git checkout -b TINKERPOP-1234 3.4-dev`
// do a bunch of stuff to implement TINKERPOP-1234 and commit/push
git checkout -b <TINKERPOP-1234-master> master
git merge TINKERPOP-1234
----

At this point, there are two branches, with the same set of commits going to `3.4-dev` and `master`. Voting will occur
on both pull requests. After a successful vote, it is time to merge. If there are no conflicts, then simply `git merge`
both pull requests to their respective branches. If there are conflicts, then there is some added work to do - time to
rebase:

[source,bash]
----
git checkout TINKERPOP-1234
git rebase origin/3.4-dev
----

Depending on the conflict, it might be a good idea to re-test before going any further, otherwise:

[source,bash]
----
git push origin TINKERPOP-1234 --force
----

Now, `git rebase` has re-written the commit history, which makes a mess of the other pull request to master. This
problem is rectified by essentially re-issuing the PR:

[source,bash]
----
git checkout TINKERPOP-1234-master
git reset --hard origin/master
git merge TINKERPOP-1234
----

Again, depending on the changes, it may make sense to re-test at this point, otherwise:

[source,bash]
----
git push origin TINKERPOP-1234-master --force
----

It should now be safe to merge both pull requests to their release branches.

IMPORTANT: Always take a moment to review the commits in a particular pull request. Be sure that they are *all* related
to the work that was done and that no extraneous commits are present that cannot be explained. Ensuring a pull request
only contains the expected commits is the responsibility of the committer as well as the reviewer.

[[dependencies]]
== Dependencies

There are many dependencies on other open source libraries in TinkerPop modules. When adding dependencies or
altering the version of a dependency, developers must consider the implications that may apply to the TinkerPop
LICENSE and NOTICE files. There are two implications to consider:

. Does the dependency fit an Apache _approved_ license?
. Given the addition or modification to a dependency, does it mean any change for TinkerPop LICENSE and NOTICE files?

Understanding these implications is important for insuring that  TinkerPop stays compliant with the Apache 2 license
that it releases under.

Regarding the first item, refer to the Apache Legal for a list of link:http://www.apache.org/legal/resolved.html[approved licenses]
that are compatible with the Apache 2 license.

The second item requires a bit more effort to follow. The Apache website offers a
link:http://www.apache.org/dev/licensing-howto.html[how-to guide] on the approach to maintaining appropriate LICENSE
and NOTICE files, but this guide is designed to offer some more specific guidance as it pertains to TinkerPop
and its distribution.

To get started, TinkerPop has both ""source"" and ""binary"" LICENSE/NOTICE files:

* Source LICENSE/NOTICE relate to files packaged with the released source code distribution:
link:https://github.com/apache/tinkerpop/blob/master/LICENSE[LICENSE] / link:https://github.com/apache/tinkerpop/blob/master/NOTICE[NOTICE]
* Binary LICENSE/NOTICE relate to files packaged with the released binary distributions:
** Gremlin Console link:https://github.com/apache/tinkerpop/blob/master/gremlin-console/src/main/static/LICENSE[LICENSE]
/ link:https://github.com/apache/tinkerpop/blob/master/gremlin-console/src/main/static/NOTICE[NOTICE]
** Gremlin Server link:https://github.com/apache/tinkerpop/blob/master/gremlin-server/src/main/static/LICENSE[LICENSE]
/ link:https://github.com/apache/tinkerpop/blob/master/gremlin-server/src/main/static/NOTICE[NOTICE]

=== Source LICENSE and NOTICE

As dependencies are not typically added to the source distribution (i.e. the source zip distribution), there is
typically no need to edit source LICENSE/NOTICE when editing a TinkerPop `pom.xml`. These files only need to be edited
if the distribution has a file added to it.  Such a situation may arise from several scenarios, but it would most
likely come from the addition of a source file from another library.

* If the file being bundled is Apache licensed, then add an entry to NOTICE.
* If the file being bundled is under a different approved license, then add an entry to LICENSE and include a copy of
that LICENSE in the root `/licenses` directory of the code repository.

=== Binary LICENSE and NOTICE

The binary LICENSE/NOTICE is perhaps most impacted by changes to the various `pom.xml` files. After altering the
`pom.xml` file of any module, build both Gremlin Console and Gremlin Server and examine the contents of the binary
distributions:

* target/gremlin-console-x.y.z-uber.jar
* target/apache-tinkerpop-gremlin-console-x.y.z-distribution.zip
* target/apache-tinkerpop-gremlin-server-x.y.z-distribution.zip

Apache licensed software does not need to be included in LICENSE, but if the new dependency is an Apache-approved
license (e.g. BSD, MIT) then it should be added in the pattern already defined. A copy of the LICENSE should be
added to the `<project>/src/main/static/licenses` directory of the code repository and the `maven-shade-plugin` section
of the `gremlin-console` `pom.xml` should be updated to reference this new license file so that it is included in the
uber jar.

To determine if changes are required to the NOTICE, first check if the bundled jar has a NOTICE file in it (typically
found in `/META-INF` directory of the jar).

* If the bundled file does not have a NOTICE, then no changes to TinkerPop's NOTICE are required.
* If the NOTICE of the file being bundled is NOT Apache licensed, then there is no change to TinkerPop's NOTICE.
* If the NOTICE of the file being bundled is Apache licensed, then include the copyright notification in TinkerPop's
NOTICE.
* If the NOTICE of the file being bundled is Apache licensed AND is an Apache Software Foundation project, then
ONLY include the portion of that NOTICE in TinkerPop's NOTICE that is unrelated to the Apache boilerplate NOTICE.
If there is no such portion that is different than the boilerplate then this NOTICE can be excluded (i.e. don't
alter TinkerPop's NOTICE at all).

Please refer to the link:http://www.apache.org/dev/licensing-howto.html#mod-notice[Modifications to Notice] section
of the Apache ""Licensing How-to"" for more information.

[[documentation]]
== Documentation

The documentation for TinkerPop is stored in the git repository in `docs/src/` and are then split into several
subdirectories, each representing a ""book"" (or its own publishable body of work). If a new AsciiDoc file is added to
a book, then it should also be included in the `index.asciidoc` file for that book, otherwise the preprocessor will
ignore it. Likewise, if a whole new book (subdirectory) is added, it must include an `index.asciidoc` file to be
recognized by the AsciiDoc preprocessor.

Adding a book also requires a change to the root `pom.xml` file. Find the ""asciidoc"" Maven profile and add a new
`<execution>` to the `asciidoctor-maven-plugin` configuration. For each book in `docs/src/`, there should be a
related `<execution>` that generates the HTML from the AsciiDoc. Follows the patterns already established by
the existing `<execution>` entries, paying special attention to the pathing of the '<sourceDirectory>',
`<outputDirectory>` and `<imagesdir>`.  Note that the `<outputDirectory>` represents where the book will exist when
uploaded to the server and should preserve the directory structure in git as referenced in `<sourceDirectory>`.

Please see the <<building-testing,Building and Testing>> section for more information on how to generate the
documentation.

=== Asciidoc Formatting Tips

*Use Asciidoctor*

Asciidoc may render differently with different tools. What may look proper and correct with an IDE may be different
than what is ultimately generated during the official build of the documentation which uses Asciidoctor. As a result
it's best to not rely on any other view of changes besides one generated by Asciidoctor.

*Anonymous Traversal Formatting*

The double underscore (i.e. `+__+`) does not typically render right and requires such code to be wrapped with
`pass:[`pass:[__]`]` or `pass:[`+__+`]`.

Cause: link:https://github.com/asciidoctor/asciidoctor/issues/1717[#1717],
link:https://github.com/asciidoctor/asciidoctor/issues/1066[#1066]

*Non-whitespace After Backtick*

Use double backtick if there is non-whitespace immediately following the trailing backtick. So rather than:
pass:[`ScriptInputFormat`'s], prefer pass:[``ScriptInputFormat``'s].

Original: [...] globally available for `ScriptInputFormat`'s `parse()` method

Fixed: [...] globally available for ``ScriptInputFormat``'s `parse()` method

Cause: link:https://github.com/asciidoctor/asciidoctor/issues/1514[#1514]

[[site]]
== Site

The content for the TinkerPop home page and related pages that make up the web site at link://tinkerpop.apache.org[tinkerpop.apache.org]
is stored in the git repository under `/docs/site`. In this way, it becomes easier for the community to provide content
presented there, because the content can be accepted via the standard workflow of a pull request. To generate the site
for local viewing, run `bin/generate-home.sh`, which will build the site in `target/site/`. PMC members can officially
publish the site with `bin/publish-home.sh <username>`.

""Publishing"" does not publish documentation (e.g. reference docs, javadocs, etc) and only publishes what is generated
from the content in `/docs/site`. Publishing the site can be performed out of band with the release cycle and is no
way tied to a version. The `master` branch should always be considered the ""current"" web site and publishing should
only happen from that branch.

[[logging]]
== Logging

TinkerPop uses SLF4j for logging and typically leans back on Log4j as the implementation. Configuring log outputs
for debugging purposes within tests can be altered by editing the `log4j-test.properties` file in each module's test
resources.  That file gets copied to the `target/test-classes` on build and surefire and failsafe plugins in maven
are then configured to point at that area of the file system for those configuration files. The properties files
can be edited to fine tune control of the log output, but generally speaking the current configuration is likely
best for everyone's general purposes, so if changes are made please revert them prior to commit.

[[io]]
== IO Documentation and Testing

The link:https://tinkerpop.apache.org/docs/x.y.z/dev/io[IO Documentation] provides more details into GraphML, GraphSON
and Gryo with a special focus on the needs of developers who are working directly with these formats. GraphSON gets
the greatest focus here as it is used as the primary IO format for link:https://tinkerpop.apache.org/docs/x.y.z/reference/#gremlin-drivers-variants[GLVs].
This documentation is largely generated from the `gremlin-io-test` module found under `gremlin-tools`. The
`gremlin-io-test` module also includes a testing framework which validates that formats don't break between TinkerPop
versions. Unfortunately, this module requires some maintenance to ensure that the documentation and tests both stay
updated.

The `gremlin-io-test` module contains a set of files in the test resources that are statically bound to the version in
which they were generated. Older versions should never be modified. The only time changes to these resources should be
accepted should be for the current `SNAPSHOT` version. The test resources are generated from the `Model` class which
contains the objects that will undergo serialization for purpose of testing. Note that these same objects in the
`Model` are also used to generate documentation.

To generate these test resources and documentation snippets based on the `Model`, use this Maven command:

[source,text]
----
mvn clean install -pl :gremlin-io-test -Dio
----

This command will generate two directories in the `/target` output directory of `gremlin-io-test`: `test-case-data`
and `dev-docs`. The contents of `test-case-data` represents the serialized `Model` objects that can be copied to the
test resources and the contents of the `dev-docs` contains asciidoc snippets that can be copied to the IO documentation.

Generating data files in the fashion mentioned above with Maven is only good for versions of TinkerPop on the 3.3.x
line because the `gremlin-io-test` module did not exist in 3.2.x. Of course, compatibility is still tested back to
those older versions. To generate test data from 3.2.x, there are Groovy scripts in the comments of the
`gryo.asciidoc` and `graphson.asciidoc` files that can copy/pasted to the Gremlin Console. They will generate the
batch of test files needed for `gremlin-io-test`.

When does this command need to be executed?

1. If a new object is added to the `Model` - in this case, the newly created data files should be copied to the
appropriate test resource directory for the current `SNAPSHOT` version and the appropriate asciidoc snippet added to
the IO asciidocs.
2. After the release of a new TinkerPop version - in this case, a new test resource directory should be created for
the `SNAPSHOT` version and the generated `test-case-data` copied in appropriately.

The second case, does require some additional discussion. When a new version is added the following classes will need
to be updated in the following ways:

*GraphBinaryCompatibility* - Include new GraphBinary 1.0 enums for the current `SNAPSHOT`.

[source,java]
----
V1_3_4_3(""3.4.3"", ""1.0"", ""v1""),
V1_3_4_4(""3.4.4"", ""1.0"", ""v1"");
----

*GryoCompatibility* - Include new Gryo 1.0 and 3.0 enums for the current `SNAPSHOT`.

[source,java]
----
V1D0_3_3_x(""3.3.x"", ""1.0"", ""v1d0""),
V3D0_3_3_x(""3.3.x"", ""3.0"", ""v3d0"")
----

*GraphSONCompatibility* - Include new GraphSON enums for each of the various GraphSON configurations and versions.

[source,java]
----
V1D0_3_3_x(""3.3.x"", ""1.0"", ""v1d0""),
V2D0_PARTIAL_3_3_x(""3.3.x"", ""2.0"", ""v2d0-partial""),
V2D0_NO_TYPE_3_3_x(""3.3.x"", ""2.0"", ""v2d0-no-types""),
V3D0_PARTIAL_3_3_x(""3.3.x"", ""3.0"", ""v3d0"");
----

*GraphBinaryCompatibilityTest* - Add the newly included `GraphBinaryCompatibility` enums to the test parameters being
careful to match the appropriate ""mapper"" to the right version.

*GryoCompatibilityTest* - Add the newly included `GryoCompatibility` enums to the test parameters being careful to
match the appropriate ""mapper"" to the right version.

*GraphSONUntypedCompatibilityTest* - Add the newly included GraphSON 1.0 and 2.0 ""untyped"" enums to the test parameters
being careful to match the appropriate ""mapper"" to the right version.

*GraphSONTypedCompatibilityTest* - Add the newly included GraphSON 3.0 and 2.0 ""typed"" enums to the test parameters
being careful to match the appropriate ""mapper"" to the right version.

At this point, all of the IO tests are rigged up properly and assuming the test resources are available a standard
`mvn clean install` should execute the compatibility tests and validate that everything is working as expected and
that there are no breaks in serialization processes.
",12089,False,1837.4429212133991,median
"// %%%%%%%%%%%%%%%%%%%%%%%%%%%% begin opencl_backend %%%%%%%%%%%%%%%%%%%%%%%%%%%%

[appendix]
[[chapter:opencl-backend]]
= OpenCL backend specification

This chapter describes how the SYCL general programming model is mapped on top
of OpenCL, and how the SYCL generic interoperability interface must be
implemented by vendors providing SYCL for OpenCL implementations to ensure SYCL
applications written for the OpenCL backend are interoperable.


[[sec:opencl:native-interop-application]]
== SYCL application interoperability native backend objects

For each <<sycl-runtime>> class which supports <<sycl-application>> interoperability,
specializations of [code]#backend_traits::input_type#
and [code]#backend_traits::return_type# must be defined as the
type of <<sycl-application>> interoperability <<native-backend-object>>
associated with [code]#SyclType# for the <<backend>>.

The types of the native backend objects for <<sycl-application>>
interoperability are described in <<table.opencl.interop>>.

[[sec:opencl:native-interop-kernel]]
== Kernel function interoperability native backend objects

For each <<sycl-runtime>> class which supports kernel function interoperability,
a specialization of [code]#backend_traits::return_type# must be defined as the type of kernel
function interoperability <<native-backend-object>> associated with [code]#SyclType#
for the <<backend>>.

The types of the native backend objects for kernel function interoperability are
described in <<table.opencl.kernelfunctioninterop.nativeobjects>>.

[[table.opencl.kernelfunctioninterop.nativeobjects]]
.Types of native backend objects kernel function interoperability
[width=""100%"",options=""header"",cols=""60%,40%""]
|====
| [code]#SyclType#                                                   | [code]#backend_return_t<backend::opencl, SyclType>#
| [code]#accessor<T, Dims, Mode, target::device>#                    | [code]#__global T*#
| [code]#accessor<T, Dims, Mode, target::constant_buffer>#           | [code]#__constant T*#
| [code]#accessor<T, Dims, Mode, target::local>#                     | [code]#__local T*#
| [code]#local_accessor<T, Dims>#                                    | [code]#__local T*#
| [code]#sampled_image_accessor<T, 1, Mode, image_target::device>#   | [code]#sampler_1dimage_pair_t#
| [code]#sampled_image_accessor<T, 2, Mode, image_target::device>#   | [code]#sampler_2dimage_pair_t#
| [code]#sampled_image_accessor<T, 3, Mode, image_target::device>#   | [code]#sampler_3dimage_pair_t#
| [code]#unsampled_image_accessor<T, 1, Mode, image_target::device># | [code]#image1d_t#
| [code]#unsampled_image_accessor<T, 2, Mode, image_target::device># | [code]#image2d_t#
| [code]#unsampled_image_accessor<T, 3, Mode, image_target::device># | [code]#image3d_t#
| [code]#stream#                                                     | [code]#__global cl_char*#
| [code]#device_event#                                               | [code]#event_t#
|====

The [code]#sampler_1dimage_pair_t#, [code]#sampler_1dimage_pair_t# and
[code]#sampler_1dimage_pair_t# types must be implemented as described below.

[source,,linenums]
----
include::{header_dir}/openclBackend/samplerImagePair.h[lines=4..-1]
----

[[sec:opencl:native-interop-destruction]]
== Destruction of interop constructed objects with reference semantics

On destruction of the last copy of an instance of a SYCL class which is
specified to have reference semantics as described in
<<sec:reference-semantics>> that was constructed using one of the <<backend>>
interoperability [code]#make_*# functions specified in
<<sec:backend-interoperability-make>> additional lifetime related operations may
be performed which are required for the underlying <<native-backend-object>>.

The additional behavior performed by the OpenCL <<backend>> for each SYCL class
is described in <<table.opencl.interop.destructors>>.

[[table.opencl.interop.destructors]]
.Destructor behavior of interop constructed objects with reference semantics
[width=""100%"",options=""header"",cols=""30%,70%""]
|====
| SYCL object     | Destructor behavior
| accessor        | No additional behavior is performed.
| buffer          | [code]#clReleaseMemObject# will be called on the native [code]#cl_mem# object provided during construction.
| context         | [code]#clReleaseContext# will be called on the native [code]#cl_context# object provided during construction.
| device          | [code]#clReleaseDevice# will be called on the native [code]#cl_device# object provided during construction.
| event           | [code]#clReleaseEvent# will be called on the native [code]#cl_event# object provided during construction.
| kernel          | [code]#clReleaseKernel# will be called on the native [code]#cl_kernel# objects provided during construction.
| kernel_bundle   | [code]#clReleaseProgram# will be called on the native [code]#cl_program# objects provided during construction.
| platform        | No additional behavior is performed.
| queue           | [code]#clReleaseCommandQueue# will be called on the native [code]#cl_command_queue# object provided during construction.
| sampled_image   | [code]#clReleaseMemObject# will be called on the native [code]#cl_mem# object provided during construction.
| unsampled_image | [code]#clReleaseMemObject# will be called on the native [code]#cl_mem# object provided during construction.
|====

// From 3.8 SYCL for OpenCL Framework
== SYCL for OpenCL framework

The SYCL framework allows applications to
use a host and one or more OpenCL devices as a single heterogeneous parallel
computer system. The framework contains the following components:

  * <<sycl-library>>: The template library provides a set of {cpp} templates
    and classes which provide the programming model to the user. It enables
    the creation of runtime classes such as SYCL queues, buffers and images,
    as well as access to some underlying OpenCL runtime object, such as
    contexts, platforms, devices and program objects.
  * <<sycl-runtime>>: The <<sycl-runtime>> interfaces with the
    underlying OpenCL implementations and handles scheduling of commands in
    queues, moving of data between host and devices, manages contexts,
    programs, kernel compilation and memory management.
  * [keyword]#OpenCL Implementation(s)#: The SYCL system assumes the
    existence of one or more OpenCL implementations available on the host
    machine.
  * SYCL <<device-compiler,device compilers>>: The SYCL <<device-compiler,device compilers>> compile
    SYCL {cpp} kernels into a format which can be executed on an OpenCL device
    at runtime. There may be more than one SYCL device compiler in a SYCL
    implementation. The format of the compiled SYCL kernels is not defined.
    A SYCL device compiler may, or may not, also compile the host parts of
    the program.

The OpenCL backend is enabled using the [code]#sycl::backend::opencl#
value of [code]#enum class backend#. That means that when the OpenCL
backend is active, the value of
[code]#sycl::is_backend_active<sycl::backend::opencl>::value# will be
[code]#true#.


== Mapping of SYCL programming model on top of OpenCL

The SYCL programming model was originally designed as a high-level model
for the OpenCL API, hence the mapping of SYCL on the OpenCL API is
mostly straightforward.

When the OpenCL backend is active on a SYCL application, all visible
OpenCL platforms are exported as SYCL platforms.

// From Architecture, Section 3.3
When a SYCL implementation executes kernels on an OpenCL
device, it achieves this by enqueuing OpenCL *commands* to
execute computations on the processing elements within a device.  The
processing elements within an OpenCL compute unit may execute a single
stream of instructions as ALUs within a SIMD unit (which execute in
lockstep with a single stream of instructions), as independent SPMD
units (where each PE maintains its own program counter) or as some
combination of the two.


// From Architecture, Section 3.3.1 (Platform mixed version support)
=== Platform mixed version support

The SYCL system presents the user with a set of devices, grouped into some
number of platforms.
The device version is an indication of the device's
capabilities, as represented by the device information returned by the
[code]#sycl::device::get_info()# member function.  Examples of attributes
associated with the device version are resource limits and information
about functionality beyond the requirements in the <<core-spec>>.
The version returned corresponds to the highest version of the OpenCL
specification for which the device is conformant, but is not higher than
the version of the device's platform which bounds the overall capabilities
of the runtime operating the device.


=== OpenCL memory model

The memory model for SYCL devices running on OpenCL platforms follows the
memory model of the OpenCL version they conform to.

In addition to <<global-memory>> , <<local-memory>> and <<private-memory>> memory,
the OpenCL backend permits the use of <<constant-memory>> space in SYCL:

  * <<constant-memory,Constant-memory>> is a region of memory that remains constant
    during the execution of a kernel. A pointer to the generic address space cannot
    represent an address to this memory region.

Work-items executing in a kernel have access to four distinct memory regions,
with the mapping between SYCL and OpenCL described in <<table.opencl.memory>>.

[[table.opencl.memory]]
.Mapping of SYCL memory regions into OpenCL memory regions
[width=""40%"",options=""header"",cols=""50%,50%""]
|====
| SYCL     | OpenCL
| Global   | Global memory
| Constant | Constant memory
| Local    | Local memory
| Private  | Private memory
|====

=== OpenCL interface for buffer command accessors

The enumerator [code]#target::constant_buffer# is deprecated, but will remain a
part of the OpenCL backend as an extension. This enables SYCL kernel functions
to access the contents of a buffer through the OpenCL device’s constant memory.

// From 3.4.1.1 OpenCL resources managed by SYCL Application
=== OpenCL resources managed by SYCL application

In OpenCL, a developer must create a <<context>> to be able to execute
commands on a device. Creating a context involves choosing a <<platform>>
and a list of <<device,devices>>. In SYCL, contexts, platforms and devices all
exist, but the user can choose whether to specify them or have the SYCL
implementation create them automatically.  The minimum required object for
submitting work to devices in SYCL is the <<queue>>, which contains
references to a platform, device and context internally.

The resources managed by SYCL are:

  . <<platform,Platforms>>: all features of OpenCL are implemented by platforms. A
    platform can be viewed as a given hardware vendor's runtime and the
    devices accessible through it. Some devices will only be accessible to
    one vendor's runtime and hence multiple platforms may be present. SYCL
    manages the different platforms for the user. In SYCL, a platform
    resource is accessible through a [code]#sycl::platform# object.
  . <<context,Contexts>>: any OpenCL resource that is acquired by the user is
    attached to a context. A context contains a collection of devices that
    the host can use and manages memory objects that can be shared between
    the devices. Data movement between devices within a context may be
    efficient and hidden by the underlying OpenCL runtime while data
    movement between contexts may involve the host. A given context can only
    wrap devices owned by a single platform. In SYCL, a context resource is
    accessible through a [code]#sycl::context# object.
  . <<device,Devices>>: platforms provide one or more devices for executing
    kernels. In SYCL, a device is accessible through a
    [code]#sycl::device# object.
  . <<kernel-bundle,Kernel bundles>>: OpenCL objects that store implementation
    data for the SYCL kernels. These objects are only required for advanced use
    in SYCL and are encapsulated in the [code]#sycl::kernel_bundle# class.
  . <<queue,Queues>>: SYCL kernels execute in command queues. The user must
    create a queue, which references an associated context, platform and
    device. The context, platform and device may be chosen automatically, or
    specified by the user. In SYCL, command queues are accessible through
    [code]#sycl::queue# objects.

// Removed from OpenCL Spec document
// In OpenCL, queues can operate using in-order execution or out-of-order
// execution. In SYCL, the implementation must provide out-of-order
// execution ordering when possible, regardless of whether the underlying
// OpenCL queue is in-order or out-of-order.


[[sec:opencl:interfacing-with-opencl]]
== Interoperability with the OpenCL API

// Original sections from 1.2.1
// From Architecture, 3.1;
//
// To ensure maximum backward-compatibility, a software developer can produce
// a program that mixes standard OpenCL C kernels and OpenCL API code with
// SYCL code and expect fully compatible interoperability.

The OpenCL backend for SYCL ensures maximum compatibility between SYCL
and OpenCL kernels and API. This includes supporting devices with
different capabilities and support for different versions of the
OpenCL C language, in addition to supporting SYCL kernels written in {cpp}.

// Original from 3.6.11, Interfacing with OpenCL
// https://cvs.khronos.org/bugzilla/show_bug.cgi?id=10426

<<sycl-runtime>> classes which encapsulate an OpenCL opaque type such as
SYCL [code]#context# or SYCL [code]#queue# must provide an
interoperability constructor taking an instance of the OpenCL opaque type.
When the OpenCL object supports reference counting, these constructors must
retain that instance to increase the reference count of the OpenCL resource.
Likewise, the destructor for the <<sycl-runtime>> classes which encapsulate a
reference counted OpenCL opaque type must release that instance to decrease the
reference count of the OpenCL resource.  Since the OpenCL [code]#platform_id#
is not reference counted, the encapsulating SYCL [code]#platform# class neither
retains nor releases this OpenCL resource.

Note that an instance of a <<sycl-runtime>> class which encapsulates an
OpenCL opaque type can encapsulate any number of instances of the OpenCL
type, unless it was constructed via the interoperability constructor, in
which case it can encapsulate only a single instance of the OpenCL type.

The lifetime of a <<sycl-runtime>> class that encapsulates an OpenCL
opaque type and the instance of that opaque type retrieved via the
[code]#get_native()# free function are not tied in either direction given
correct usage of OpenCL reference counting. For example if a user were to
retrieve a [code]#cl_command_queue# instance from a SYCL
[code]#queue# instance and then immediately destroy the SYCL
[code]#queue# instance, the [code]#cl_command_queue# instance is
still valid. Or if a user were to construct a SYCL [code]#queue#
instance from a [code]#cl_command_queue# instance and then immediately
release the [code]#cl_command_queue# instance, the SYCL
[code]#queue# instance is still valid.

Note that a <<sycl-runtime>> class that encapsulates an OpenCL opaque type
is not responsible for any incorrect use of OpenCL reference counting
outside of the <<sycl-runtime>>. For example if a user were to retrieve a
[code]#cl_command_queue# instance from a SYCL [code]#queue#
instance and then release the [code]#cl_command_queue# instance more
than once without any prior retain then the SYCL [code]#queue# instance
that the [code]#cl_command_queue# instance was retrieved from is now
undefined.

Note that an instance of the SYCL [code]#buffer# or SYCL
[code]#image# class templates constructed via the interoperability
constructor is free to copy from the [code]#cl_mem# into another memory
allocation within the <<sycl-runtime>> to achieve normal SYCL semantics,
for as long as the SYCL [code]#buffer# or SYCL [code]#image#
instance is alive.

<<table.opencl.interop>> relates SYCL objects
to their OpenCL native type in the SYCL application.

[[table.opencl.interop]]
.List of native types per SYCL object in the OpenCL backend
[width=""100%"",options=""header"",separator=""@"",cols=""15%,15%,15%,55%""]
|====
@ [code]#SyclType#
   @ [code]#backend_input_t<backend::opencl, SyclType>#
   @ [code]#backend_return_t<backend::opencl, SyclType>#
   @ Description
a@
[source]
----
platform
----
   a@ [code]#cl_platform_id#
   a@ [code]#cl_platform_id#
   a@ A SYCL platform object encapsulates an OpenCL platform ID.
a@
[source]
----
device
----
   a@ [code]#cl_device_id#
   a@ [code]#cl_device_id#
   a@ A SYCL device object encapsulates an OpenCL device ID.
a@
[source]
----
context
----
   a@ [code]#cl_context#
   a@ [code]#cl_context#
   a@ A SYCL context object encapsulates an OpenCL context object.
a@
[source]
----
queue
----
   a@ [code]#cl_command_queue#
   a@ [code]#cl_command_queue#
   a@ A SYCL queue object encapsulates an OpenCL queue object.
a@
[source]
----
kernel
----
   a@ [code]#cl_kernel#
   a@ [code]#cl_kernel#
   a@ A SYCL kernel object encapsulates an OpenCL kernel object.
a@
[source]
----
template <bundle_state State>
kernel_bundle<State>
----
   a@ [code]#cl_program#
   a@ [code]#std::vector<cl_program>#
   a@ A SYCL kernel bundle can encapsulate one or more OpenCL program objects.
      It can also encapsulate one or more OpenCL kernel objects
      which can be retrieved using the appropriate [code]#kernel# object.
a@
[source]
----
event
----
   a@ [code]#std::vector<cl_event>#
   a@ [code]#std::vector<cl_event>#
   a@ // Original from 3.6.5.1 Synchronization in the SYCL application

A SYCL event can encapsulate one or multiple OpenCL events,
representing a number of dependencies in the same or different contexts,
that must be satisfied for the SYCL event to be complete.
a@
[source]
----
buffer
----
   a@ [code]#cl_mem#
   a@ [code]#std::vector<cl_mem>#
   a@ SYCL buffers containing OpenCL memory objects
      can handle multiple [code]#cl_mem# objects in the same or different context.
      The interoperability interface will return a list of active buffers in the SYCL runtime.
a@
[source]
----
sampled_image
----
   a@ [code]#cl_mem#
   a@ [code]#std::vector<cl_mem>#
   a@ SYCL sampled images containing OpenCL image objects
      can handle multiple underlying [code]#cl_mem# objects
      at the same time in the same or different OpenCL contexts.
      The interoperability interface will return a list of active images in the SYCL runtime.
a@
[source]
----
unsampled_image
----
   a@ [code]#cl_mem#
   a@ [code]#std::vector<cl_mem>#
   a@ SYCL unsampled images containing OpenCL image objects
      can handle multiple underlying [code]#cl_mem# objects
      at the same time in the same or different OpenCL contexts.
      The interoperability interface will return a list of active images in the SYCL runtime.
|====

Inside the SYCL kernel, the SYCL API offers interoperability with OpenCL device types.
<<table.opencl.kerneltypes>> describes the mapping of kernel types.

[[table.opencl.kerneltypes]]
.List of native types per SYCL object on kernel code
[width=""100%"",options=""header"",separator=""@"",cols=""65%,35%""]
|====
@ SYCL kernel native types in OpenCL @ Description
a@
[source]
----
multi_ptr::get_decorated()
----
   a@ Returns a pointer in the OpenCL address space
      corresponding to the type of multi pointer object
|====

// \\section{SYCL Programming interface}
// From 3.6 SYCL programming model (eliminated)
// SYCL programs are explicitly parallel and expose the full heterogeneous
// parallelism of the underlying machine model of OpenCL. This includes exposing
// the data-parallelism, multiple execution devices and multiple memory storage
// spaces of OpenCL. However, SYCL adds on top of OpenCL a higher level of
// abstraction allowing developers to hide much of the complexity from the source
// code, when a developer so chooses.


// From 3.7 memory object
When a buffer or image is allocated on more than
one OpenCL device, if these devices are on separate contexts then multiple
[code]#cl_mem# objects may be allocated for the memory object, depending on
whether the object has actively been used on these devices yet or not.


// From 3.10 Language restrictions in kernels

Some types in SYCL vary according to pointer size or vary on the host
according to the host ABI, such as [code]#size_t# or [code]#long#. In order
for the SYCL device compiler to ensure that the sizes of
these types match the sizes on the host and to enable data of these types
to be shared between host and device, the OpenCL interoperability types
are defined, [code]#sycl::cl_int# and [code]#sycl::cl_size_t#.

The OpenCL C function qualifier [code]#+__kernel+# and the access
qualifiers: [code]#+__read_only+#, [code]#+__write_only+# and [code]#+__read_write+#
are not exposed in SYCL via keywords, but are instead encapsulated in
SYCL's parameter passing system inside accessors. Users wishing to
achieve the OpenCL equivalent of these qualifiers in SYCL should
instead use SYCL accessors with equivalent semantics.

// From 3.10.1 SYCL Linker
Any OpenCL C function included in a pre-built OpenCL library can be
defined as an [code]#extern ""C""# function and the OpenCL program
has to be linked against any SYCL program that contains kernels using
the external function. In this case, the data types used have to comply with
the interoperability aliases defined in <<table.types.aliases>>.


== Programming interface

The following section describes the OpenCL-specific API.

=== Construct SYCL objects from OpenCL ones

The OpenCL backend provides the following specializations of the
[code]#make_{sycl_class}# template functions which are defined in
<<sec:backend-interoperability-make>>.  These functions are in the
[code]#sycl# namespace.

[width=""100%"",options=""header"",separator=""@"",cols=""40%,60%""]
|====
@ OpenCL interoperability function @ Description
a@
[source]
----
context make_context(
    const cl_context &clContext,
    const async_handler &asyncHandler = {})
----
   a@ Constructs a SYCL [code]#context# instance from an OpenCL [code]#cl_context# in accordance with the requirements described in <<sec:backend-interoperability>>.
a@
[source]
----
event make_event(const cl_event &clEvent,
    const context &syclContext)
----
   a@ Constructs a SYCL [code]#event# instance from an OpenCL [code]#cl_event# in accordance with the requirements described in <<sec:backend-interoperability>>.
a@
[source]
----
device make_device(
    const cl_device_id &clDeviceId)
----
   a@ Constructs a SYCL [code]#device# instance from an OpenCL [code]#cl_device_id# in accordance with the requirements described in <<sec:backend-interoperability>>.
a@
[source]
----
platform make_platform(
    const cl_platform_id &clPlatformId)
----
   a@ Constructs a SYCL [code]#platform# instance from an OpenCL [code]#cl_platform_id# in accordance with the requirements described in <<sec:backend-interoperability>>.
a@
[source]
----
queue make_queue(
    const cl_command_queue &clQueue,
    const context &syclContext,
    const async_handler &asyncHandler = {})
----
   a@ Constructs a SYCL [code]#queue# instance with an optional
      [code]#async_handler# from an OpenCL [code]#cl_command_queue#
      in accordance with the requirements described
      in <<sec:backend-interoperability>>.
a@
[source]
----
template <typename T, int dimensions = 1,
          typename AllocatorT = buffer_allocator<std::remove_const_t<T>>>
buffer<T, dimensions, AllocatorT> make_buffer(
    const cl_mem &clMemObject,
    const context &syclContext,
    event availableEvent)
----
   a@ Available only when: [code]#dimensions == 1#.

Constructs a SYCL [code]#buffer# instance from an OpenCL [code]#cl_mem# in accordance with the requirements described in <<sec:backend-interoperability>>.
The instance of the SYCL [code]#buffer# class template being constructed must wait for the SYCL [code]#event# parameter, [code]#availableEvent# to signal that the [code]#cl_mem# instance is ready to be used.
The SYCL [code]#context# parameter [code]#syclContext# is the context associated with the memory object.

a@
[source]
----
template <typename T, int dimensions = 1,
          typename AllocatorT = buffer_allocator<std::remove_const_t<T>>>
buffer<T, dimensions, AllocatorT> make_buffer(
    const cl_mem &clMemObject,
    const context &syclContext)
----
   a@ Available only when: [code]#dimensions == 1#.

Constructs a SYCL [code]#buffer# instance from an OpenCL [code]#cl_mem# in accordance with the requirements described in <<sec:backend-interoperability>>.

a@
[source]
----
template <int dimensions = 1,
          typename AllocatorT = image_allocator>
sampled_image<dimensions, AllocatorT> make_sampled_image(
    const cl_mem &clMemObject,
    const context &syclContext,
    image_sampler syclImageSampler,
    event availableEvent)
----
   a@ Constructs a SYCL [code]#sampled_image# instance from an OpenCL [code]#cl_mem# in accordance with the requirements described in <<sec:backend-interoperability>>.
      The instance of the SYCL [code]#image# class template being constructed must wait for the SYCL [code]#event# parameter, [code]#availableEvent# to signal that the [code]#cl_mem# instance is ready to be used.
      The SYCL [code]#context# parameter [code]#syclContext# is the context associated with the memory object. 

a@
[source]
----
template <int dimensions = 1,
          typename AllocatorT = image_allocator>
sampled_image<dimensions, AllocatorT> make_sampled_image(
    const cl_mem &clMemObject,
    const context &syclContext,
    image_sampler syclImageSampler)
----
   a@ Constructs a SYCL [code]#sampled_image# instance from an OpenCL [code]#cl_mem# in accordance with the requirements described in <<sec:backend-interoperability>>.
      The SYCL [code]#context# parameter [code]#syclContext# is the context associated with the memory object.

a@
[source]
----
template <int dimensions = 1,
          typename AllocatorT = image_allocator>
unsampled_image<dimensions, AllocatorT> make_unsampled_image(
    const cl_mem &clMemObject,
    const context &syclContext,
    event availableEvent)
----
   a@ Constructs a SYCL [code]#unsampled_image# instance from an OpenCL [code]#cl_mem# in accordance with the requirements described in <<sec:backend-interoperability>>.
      The instance of the SYCL [code]#image# class template being constructed must wait for the SYCL [code]#event# parameter, [code]#availableEvent# to signal that the [code]#cl_mem# instance is ready to be used.
      The SYCL [code]#context# parameter [code]#syclContext# is the context associated with the memory object.

a@
[source]
----
template <int dimensions = 1,
          typename AllocatorT = image_allocator>
unsampled_image<dimensions, AllocatorT> make_unsampled_image(
    const cl_mem &clMemObject,
    const context &syclContext)
----
   a@ Constructs a SYCL [code]#unsampled_image# instance from an OpenCL [code]#cl_mem# in accordance with the requirements described in <<sec:backend-interoperability>>.
a@
[source]
----
kernel make_kernel(const cl_kernel &clKernel,
                   const context &syclContext);
----
   a@ Constructs a SYCL [code]#kernel# instance from an OpenCL kernel object.
a@
[source]
----
template <bundle_state State>
kernel_bundle<State> make_kernel_bundle(
    const cl_program &clProgram,
    const context& syclContext)
----
   a@ Constructs a SYCL [code]#kernel_bundle# instance from an OpenCL
      [code]#cl_program# for the devices in [code]#syclContext#
      in accordance with the requirements described in <<sec:backend-interoperability>>.
      The SYCL [code]#context# must represent the same underlying OpenCL
      context associated with the OpenCL program object.

The [code]#state# specifies the expected [code]#kernel_bundle# state.
      The mapping between the [code]#kernel_bundle# state
      and OpenCL program state ([code]#CL_PROGRAM_BINARY_TYPE#) is as follows:

      * [code]#bundle_state::input# - [code]#CL_PROGRAM_BINARY_TYPE_NONE#
      * [code]#bundle_state::object# -
         [code]#CL_PROGRAM_BINARY_TYPE_COMPILED_OBJECT# or
         [code]#CL_PROGRAM_BINARY_TYPE_INTERMEDIATE# or
         [code]#CL_PROGRAM_BINARY_TYPE_LIBRARY#.
      * [code]#bundle_state::executable# - [code]#CL_PROGRAM_BINARY_TYPE_EXECUTABLE#

If the internal state of the OpenCL program doesn't match [code]#state#,
      the kernel bundle will be compiled and linked as necessary.
      If the OpenCL program is already an executable binary,
      but the specified [code]#state# is not [code]#bundle_state::executable#,
      an [code]#exception# with the [code]#errc::invalid# error code is thrown.
      If the specified [code]#state# is [code]#bundle_state::input#,
      but the OpenCL program already has a binary associated with it,
      an [code]#exception# with the [code]#errc::invalid# error code is thrown.

Throws an [code]#exception# with the [code]#errc::invalid# error code
   if any error is produced by the <<backend>>.
|====


=== Extension query

Platforms and devices with an OpenCL backend may support extensions.
For convenience, the extensions supported by a platform or device can be queried
through the following functions provided in the [code]#sycl::opencl# namespace.

[width=""100%"",options=""header"",separator=""@"",cols=""35%,65%""]
|====
@ Extension query @ Description
a@
[source]
----
bool has_extension(
    const sycl::platform &syclPlatform,
    const std::string &extension)
----
   a@ Returns true if the OpenCL platform associated with [code]#syclPlatform#
   supports the extension identified by [code]#extension#, otherwise it returns
   false. If [code]#syclPlatform.get_backend() != sycl::backend::opencl# an
   [code]#exception# with the [code]#errc::backend_mismatch# error code is
   thrown.
a@
[source]
----
bool has_extension(
    const sycl::device &syclDevice,
    const std::string &extension)
----
   a@ Returns true if the OpenCL device associated with [code]#syclDevice#
   supports the extension identified by [code]#extension#, otherwise it returns
   false. If [code]#syclDevice.get_backend() != sycl::backend::opencl# an
   [code]#exception# with the [code]#errc::backend_mismatch# error code is
   thrown.
|====

=== Reference counting

Most OpenCL objects are reference counted. The SYCL general programming model
doesn't require that native objects are reference counted. However, for
convenience, the following function is provided in the
[code]#sycl::opencl# namespace.

[width=""100%"",options=""header"",separator=""@"",cols=""35%,65%""]
|====
@ Reference counting @ Description
a@
[source]
----
template <typename openCLT>
    cl_uint get_reference_count(openCLT obj)
----
   a@ Returns the reference count of the given object
|====


=== Errors and limitations

If there is an OpenCL error associated with an exception triggered, then the
OpenCL error code can be obtained by the free function [code]#cl_int sycl::opencl::get_error_code(sycl::exception&)#. In the case where there is
no OpenCL error associated with the exception triggered, the OpenCL error
code will be [code]#CL_SUCCESS#.


// TODO: Errors and limitations
// The only exception to
// this rule is when a buffer is constructed from a [code]#cl_mem#
// object to interoperate with OpenCL. Use of an interoperability
// buffer on a queue mapping to a context other than that in which the
// [code]#cl_mem# was created is an error.

// Since data management and storage is handled by the <<sycl-runtime>>, the
// [code]#event# class is used for providing the appropriate interface for
// OpenCL/SYCL interoperability. In the case where SYCL objects contain
// OpenCL memory objects created outside of the SYCL mechanism, then events
// can be used to provide the <<sycl-runtime>> with the initial events that it has
// to synchronize against. However, the events mechanism does not provide
// full interoperability with OpenCL during SYCL code execution.
// Interoperability is achieved by using the synchronization rules with the
// [code]#buffer# and [code]#image# classes.


[[sec:opencl:interop-kernel-bundle]]
=== Interoperability with kernel bundles

In <<opencl12, OpenCL>> any kernel function that is enqueued over an nd-range
is represented by a [code]#cl_kernel# and must be compiled and linked via a
[code]#cl_program# using [code]#clBuildProgram#,
[code]#clCompileProgram# and [code]#clLinkProgram#.

For OpenCL <<backend>> this detail is abstracted away by <<kernel bundle,kernel bundles>> and
a [code]#kernel_bundle# object containing all <<sycl-kernel-function,SYCL kernel functions>>
is retrieved by calling the free function [code]#get_kernel_bundle#.

The OpenCL <<backend>> specification provides additional free functions
which provide convenience functions for constructing kernel bundles
from OpenCL specific objects.

[source,,linenums]
----
include::{header_dir}/openclBackend/createBundle.h[lines=4..-1]
----

[source,,linenums]
----
template <bundle_state State>
kernel_bundle<State> create_bundle(const context &ctxt,
                                   const std::vector<device> &devs,
                                   const std::vector<cl_program> &clPrograms)
----
  . _Preconditions:_ The <<context>> specified by [code]#ctxt#
    must be associated with the OpenCL <<backend>>.
    All devices in [code]#devs# must be associated with [code]#ctxt#.
    All OpenCL programs in [code]#clPrograms# must be associated with [code]#ctxt#.
+
--
_Effects:_ Constructs a <<kernel-bundle>> in the specified [code]#bundle_state#
from the provided list of OpenCL programs and associated with the
<<context>> specified by [code]#syclContext# by invoking the necessary OpenCL APIs.
Follows the same rules as calling [code]#make_kernel_bundle# on a single OpenCL program,
except that the rules apply to all OpenCL programs in [code]#clPrograms#.
Multiple programs will be linked together into a single one
if required by the requested [code]#State#.
The constructed [code]#kernel_bundle# will retain all provided OpenCL programs
and will also release them on destruction.

_Throws:_ An [code]#exception# with the [code]#errc::build# error code if any error is produced
by invoking the OpenCL APIs.
--

[source,,linenums]
----
kernel_bundle<bundle_state::executable>
create_bundle(const context &ctxt, const std::vector<device> &devs,
              const std::vector<cl_kernel> &clKernels)
----
  . _Preconditions:_ The <<context>> specified by [code]#ctxt#
    must be associated with the OpenCL <<backend>>.
    All devices in [code]#devs# must be associated with [code]#ctxt#.
    All OpenCL kernels in [code]#clKernels# must be associated with [code]#ctxt#.
+
--
_Effects:_ Constructs an executable <<kernel-bundle>>
from the provided list of OpenCL kernels and associated with the
<<context>> specified by [code]#syclContext# by invoking the necessary OpenCL APIs.
[code]#cl_kernel# objects might be associated with different [code]#cl_program# objects,
the kernel bundle will encapsulate all of them.

_Throws:_ An [code]#exception# with the [code]#errc::build# error code if any error is produced
by invoking the OpenCL APIs.
--


=== Interoperability with kernels

A [code]#kernel_bundle# object contains one or multiple OpenCL programs
and one or multiple OpenCL kernels.
Calling [code]#kernel_bundle::get_kernel# returns a [code]#kernel# object
 which can be invoked by any of
<<kernel-invocation-command,kernel invocation commands>> such as [code]#parallel_for# which take
a [code]#kernel# but not <<sycl-kernel-function>>.

Calling [code]#make_kernel# must trigger a call to [code]#clRetainKernel#
and the resulting [code]#kernel# object must call
[code]#clReleaseKernel# on destruction.

It is also possible to construct a <<kernel-bundle>> from previously created OpenCL
[code]#cl_kernel# objects by calling the free function [code]#create_bundle#
as described in <<sec:opencl:interop-kernel-bundle>>.

The kernel arguments for the OpenCL C kernel kernel can either be set prior to
creating the [code]#kernel# object or by calling [code]#set_arg# or [code]#set_args#
member functions of the [code]#handler# class.

If kernel arguments are set prior to creating the [code]#kernel# object the
<<sycl-runtime>> is not responsible for managing the data of these arguments.


[[sec:opencl:kernel-conventions-sycl]]
=== OpenCL kernel conventions and SYCL

OpenCL and SYCL use opposite conventions for the unit stride dimension. SYCL
aligns with {cpp} conventions, which is important to understand from a
performance perspective when porting code to SYCL. The unit stride
dimension, at least for data, is implicit in the linearization equations in
SYCL (<<sec:multi-dim-linearization>>) and OpenCL. SYCL aligns with
{cpp} array subscript ordering [code]#arr[a][b][c]#, in that range
constructor dimension ordering used to launch a kernel (e.g.
[code]#range<3> R{a,b,c}#) and range and ID queries within a kernel,
are ordered in the same way as the {cpp} multi-dimensional subscript operators
(unit stride on the right).

When specifying a [code]#range# as the global or local size
in a [code]#parallel_for# that invokes an OpenCL interop kernel (through
[code]#cl_kernel# interop),
the highest dimension of the range in SYCL will map to the
lowest dimension within the OpenCL kernel.  That statement applies to both
an underlying enqueue operation such as [code]#clEnqueueNDRangeKernel#
in OpenCL, and also ID and size queries within the OpenCL kernel.
For example, a 3D global range specified in SYCL as:

[source]
----
range<3> R{r0,r1,r2};
----

maps to an [code]#clEnqueueNDRangeKernel# [code]#global_work_size# argument
of:

[source]
----
size_t cl_interop_range[3] = {r2,r1,r0};
----

Likewise, a 2D global range specified in SYCL as:

[source]
----
range<2> R{r0,r1};
----

maps to an [code]#clEnqueueNDRangeKernel# [code]#global_work_size# argument
of:

[source]
----
size_t cl_interop_range[2] = {r1,r0};
----

The mapping of highest dimension in SYCL to lowest dimension in OpenCL applies to all
operations where a multi-dimensional construct must be mapped, such as when mapping SYCL
explicit memory operations to OpenCL APIs like [code]#clEnqueueCopyBufferRect#.

Work-item and work-group ID and range queries have the same reversed
convention for unit stride dimension between SYCL and OpenCL. For example,
with three, two, or one dimensional SYCL global ranges, OpenCL and SYCL
kernel code queries relate to the range as shown in
<<table.syclOpenCL.mapping>>. The ""SYCL kernel query"" column
applies for SYCL-defined kernels, and the ""OpenCL kernel query"" column
applies for kernels defined through OpenCL interop.

// Jon: Need to code-format most of these cells and use gray backgrounds on
// column-spanning sub-titles.

[[table.syclOpenCL.mapping]]
.Example range mapping from SYCL enqueued three dimensional global [code]#range# to OpenCL and SYCL queries
[width=""100%"",options=""header"",cols=""60%,20%,20%""]
|====
| SYCL kernel query | OpenCL kernel query | Returned Value

3+|With enqueued 3D SYCL global [code]#range# of [code]#range<3> R{r0,r1,r2}#
| nd_item::get_global_range(0) / item::get_range(0)
    | get_global_size(2)
    | [code]#r0#
| nd_item::get_global_range(1) / item::get_range(1)
    | get_global_size(1)
    | [code]#r1#
| nd_item::get_global_range(2) / item::get_range(2)
    | get_global_size(0)
    | [code]#r2#
| nd_item::get_global_id(0) / item::get_id(0)
    | get_global_id(2)
    | Value in range 0..([code]#r0-1)}#
| nd_item::get_global_id(1) / item::get_id(1)
    | get_global_id(1)
    | Value in range 0..([code]#r1-1)}#
| nd_item::get_global_id(2) / item::get_id(2)
    | get_global_id(0)
    | Value in range 0..([code]#r2-1)}#

3+|With enqueued 2D SYCL global [code]#range# of [code]#range<2> R{r0,r1}#
| nd_item::get_global_range(0) / item::get_range(0)
    | get_global_size(1)
    | [code]#r0#
| nd_item::get_global_range(1) / item::get_range(1)
    | get_global_size(0)
    | [code]#r1#
| nd_item::get_global_id(0) / item::get_id(0)
    | get_global_id(1)
    | Value in range 0..([code]#r0-1)}#
| nd_item::get_global_id(1) / item::get_id(1)
    | get_global_id(0)
    | Value in range 0..([code]#r1-1)}#

3+|With enqueued 1D SYCL global [code]#range# of [code]#range<1> R{r0}#
| nd_item::get_global_range(0) / item::get_range(0)
    | get_global_size(0)
    | [code]#r0#
| nd_item::get_global_id(0) / item::get_id(0)
    | get_global_id(0)
    | Value in range 0..([code]#r0-1)}#

|====


=== Data types

The OpenCL C language standard <<opencl12, Section 6.11>> defines its own built-in
scalar data types, and these have additional requirements in terms of size and
signedness on top of what is guaranteed by ISO {cpp}. For the purpose of
interoperability and portability, SYCL defines a set of aliases to {cpp} types
within the [code]#sycl::opencl# namespace using the [code]#cl_#
prefix. These aliases are described in <<table.types.aliases>>


[[table.types.aliases]]
.Scalar data type aliases supported by SYCL OpenCL backend
[width=""100%"",options=""header"",separator=""@"",cols=""25%,75%""]
|====
@ Scalar data type alias @ Description
a@
[source]
----
cl_bool
----
   a@ Alias to a conditional data type which can be either true or false. The value
      true expands to the integer constant 1 and the value false expands to the
      integer constant 0.

a@
[source]
----
cl_char
----
   a@ Alias to a signed 8-bit integer, as defined by the {cpp} core language.

a@
[source]
----
cl_uchar
----
   a@ Alias to an unsigned 8-bit integer, as defined by the {cpp} core language.

a@
[source]
----
cl_short
----
   a@ Alias to a signed 16-bit integer, as defined by the {cpp} core language.

a@
[source]
----
cl_ushort
----
   a@ Alias to an unsigned 16-bit integer, as defined by the {cpp} core language.

a@
[source]
----
cl_int
----
   a@ Alias to a signed 32-bit integer, as defined by the {cpp} core language.

a@
[source]
----
cl_uint
----
   a@ Alias to an unsigned 32-bit integer, as defined by the {cpp} core language.

a@
[source]
----
cl_long
----
   a@ Alias to a signed 64-bit integer, as defined by the {cpp} core language.

a@
[source]
----
cl_ulong
----
   a@ Alias to an unsigned 64-bit integer, as defined by the {cpp} core language.

a@
[source]
----
cl_float
----
   a@ Alias to a 32-bit floating-point. The float data type must conform to the IEEE
      754 single precision storage format.

a@
[source]
----
cl_double
----
   a@ Alias to a 64-bit floating-point. The double data type must conform to the IEEE
      754 double precision storage format.

a@
[source]
----
cl_half
----
   a@ Alias to a 16-bit floating-point. The half data type must conform to
      the IEEE 754-2008 half precision storage format. Kernels using this type
      are only supported on devices that have [code]#aspect::fp16#, as described
      in <<sec:optional-kernel-features>>.

|====



== Preprocessor directives and macros

  * [code]#SYCL_BACKEND_OPENCL# substitutes to [code]#1# if the OpenCL <<backend>>
    is active while building the SYCL application.


=== Offline linking with OpenCL C libraries

SYCL supports linking <<sycl-kernel-function,SYCL kernel functions>> with OpenCL C libraries
during offline compilation or during online compilation by the
<<sycl-runtime>> within a SYCL application.

Linking with OpenCL C kernel functions offline is an optional feature
and is unspecified. Linking with OpenCL C kernel functions online is
performed by using the SYCL [code]#kernel_bundle# class to compile and
link an OpenCL C source; using the [code]#compile_with_source# or
[code]#build_with_source# member functions.

OpenCL C functions that are linked with, using either offline or online
compilation, must be declared as [code]#extern ""C""# function
declarations. The function parameters of these function declarations must be
defined as the OpenCL C interoperability aliases; [code]#pointer# of
the [code]#multi_ptr# class template, [code]#vector_t# of the
[code]#vec# class template and scalar data type aliases described in
<<table.types.aliases>>.

// \\include{opencl_extensions}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%% begin opencl_extensions %%%%%%%%%%%%%%%%%%%%%%%%%%%%

== SYCL support of non-core OpenCL features

In addition to the OpenCL core features, SYCL also provides support for OpenCL
extensions which provide features in OpenCL via khr extensions.

Some extensions are natively supported within the SYCL interface, however some
can only be used via the OpenCL interoperability interface. The SYCL interface
required for native extensions must be available. However if the respective
extension is not supported by the executing SYCL [code]#device#, the
<<sycl-runtime>> must throw an [code]#exception# with the
[code]#errc::feature_not_supported# or [code]#errc::kernel_not_supported# error
codes.

The OpenCL backend exposes some khr extensions to SYCL applications through the
[code]#sycl::aspect# enumerated type.  Therefore, applications can query
for the existence of these khr extensions by calling the [code]#device::has()#
or [code]#platform::has()# member functions.

All OpenCL extensions are available through the OpenCL interoperability
interface, but some can also be used through core SYCL APIs.
<<table.extensionsupport>> shows which these are.
<<table.extensionsupport>> also shows the mapping from each OpenCL
extension name to its associated SYCL device [code]#aspect# when one is
available.


[[table.extensionsupport]]
.SYCL support for OpenCL 1.2 extensions
[width=""100%"",options=""header"",cols=""43%,37%,20%""]
|====
| SYCL Aspect              | OpenCL Extension                      | Core SYCL API
| [code]#aspect::atomic64# | [code]#cl_khr_int64_base_atomics#     | Yes
| [code]#aspect::atomic64# | [code]#cl_khr_int64_extended_atomics# | Yes
| [code]#aspect::fp16#     | [code]#cl_khr_fp16#                   | Yes
| -                        | [code]#cl_khr_3d_image_writes#        | Yes
| -                        | [code]#cl_khr_gl_sharing#             | No
| -                        | [code]#cl_apple_gl_sharing#           | No
| -                        | [code]#cl_khr_d3d10_sharing#          | No
| -                        | [code]#cl_khr_d3d11_sharing#          | No
| -                        | [code]#cl_khr_dx9_media_sharing#      | No
|====



[[sec:opencl:extension-fp16]]
=== Half precision floating-point

The half scalar data type: [code]#half# and the half vector data types:
[code]#half1#, [code]#half2#, [code]#half3#,
[code]#half4#, [code]#half8# and [code]#half16# must be
available at compile-time. However a kernel using these types is only
supported on devices that have [code]#aspect::fp16#, as described in
<<sec:optional-kernel-features>>.

The conversion rules for half precision types follow the same rules as in
the OpenCL 1.2 extensions specification <<openclext12, par. 9.5.1>>.

The math functions for half precision types follow the same rules as in the
OpenCL 1.2 extensions specification <<opencl12,  par. 9.5.2, 9.5.3, 9.5.4,
9.5.5>>. The allowed error in ULP(Unit in the Last Place) is
less than 8192, corresponding to <<opencl12, Table 6.9 of the OpenCL 1.2 specification>>.


=== Writing to 3D image memory objects

The [code]#unsampled_image_accessor# class
in SYCL supports member functions for writing
3D image memory objects, but this functionality is only allowed on a device
if the extension [code]#cl_khr_3d_image_writes# is
supported on that <<device>>.

// TODO: Should opencl::aspect::3d_image_writes be promoted to a core SYCL aspect?


=== Interoperability with OpenGL

Interoperability between SYCL and OpenGL is not directly provided by the SYCL interface,
however can be achieved via the SYCL OpenCL interoperability interface.


== Correspondence of some OpenCL features to SYCL

This section describes the correspondence between some OpenCL features and
features in the <<core-spec>> that provide similar functionality.  All content
in this section is non-normative.

=== Work-item functions

The OpenCL 1.2 specification document <<opencl12, ch. 6.12.1 in Table 6.7>>
defines work-item functions that tell various information about the currently
executing work item in an OpenCL kernel.  SYCL provides equivalent
functionality through the item and group classes that are defined in
<<subsec:item.class>>, <<nditem-class>> and <<group-class>>.

=== Vector data load and store functions

The functionality from the OpenCL functions as defined in the OpenCL 1.2
specification document <<opencl12, par. 6.12.7>> is available in SYCL through
the [code]#vec# class in <<sec:vector.type>>.

=== Synchronization functions

In SYCL the OpenCL [keyword]#synchronization functions# are available through
the [code]#nd_item# class (<<nditem-class>>), as they are applied to
work-items for local or global address spaces. Please
see <<table.members.nditem>>.

=== [code]#printf# function

The functionality of the [code]#printf# function is covered by the
[code]#stream# class (<<subsec:stream>>), which has the
capability to print to standard output all of the SYCL classes and primitives,
and covers the capabilities defined in the OpenCL 1.2 specification
document <<opencl12, par. 6.12.13>>.

// %%%%%%%%%%%%%%%%%%%%%%%%%%%% end opencl_extensions %%%%%%%%%%%%%%%%%%%%%%%%%%%%

// %%%%%%%%%%%%%%%%%%%%%%%%%%%% end opencl_backend %%%%%%%%%%%%%%%%%%%%%%%%%%%%
",12486,False,2143.4492687996963,median
"// Copyright (c) 2020 INRA 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)

#ifdef _WIN32
#define NOMINMAX
#define WINDOWS_LEAN_AND_MEAN
#endif

#include <irritator/ext.hpp>

#include ""application.hpp""
#include ""dialog.hpp""
#include ""editor.hpp""
#include ""internal.hpp""

#include <cinttypes>
#include <fstream>
#include <string>

#include <fmt/format.h>
#include <irritator/core.hpp>
#include <irritator/examples.hpp>
#include <irritator/io.hpp>

namespace irt {

static ImVec4 operator*(const ImVec4& lhs, const float rhs) noexcept
{
    return ImVec4(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs);
}

editor::editor() noexcept
{
    context = ImNodes::EditorContextCreate();
    ImNodes::PushAttributeFlag(
      ImNodesAttributeFlags_EnableLinkDetachWithDragClick);
    ImNodesIO& io                           = ImNodes::GetIO();
    io.LinkDetachWithModifierClick.Modifier = &ImGui::GetIO().KeyCtrl;

    settings.compute_colors();
}

editor::~editor() noexcept
{
    if (context) {
        ImNodes::EditorContextSet(context);
        ImNodes::PopAttributeFlag();
        ImNodes::EditorContextFree(context);
    }
}

void editor::settings_manager::compute_colors() noexcept
{
    gui_hovered_model_color =
      ImGui::ColorConvertFloat4ToU32(gui_model_color * 1.25f);
    gui_selected_model_color =
      ImGui::ColorConvertFloat4ToU32(gui_model_color * 1.5f);

    gui_hovered_model_transition_color =
      ImGui::ColorConvertFloat4ToU32(gui_model_transition_color * 1.25f);
    gui_selected_model_transition_color =
      ImGui::ColorConvertFloat4ToU32(gui_model_transition_color * 1.5f);
}

void editor::clear() noexcept { sim.clear(); }

void editor::free_children(const ImVector<int>& nodes) noexcept
{
    for (int i = 0, e = nodes.size(); i != e; ++i) {
        const auto* mdl = sim.models.try_to_get(nodes[i]);
        if (!mdl)
            continue;

        const auto child_id = sim.models.get_id(mdl);
        log_w.log(7, ""delete %"" PRIu64 ""\\n"", child_id);
        sim.deallocate(child_id);

        observation_dispatch(
          get_index(child_id),
          [this](auto& outs, const auto id) { outs.free(id); });

        observation_outputs[get_index(child_id)] = std::monostate{};
    }
}

static void compute_connection_distance(const model_id src,
                                        const model_id dst,
                                        editor&        ed,
                                        const float    k)
{
    const auto v = get_index(src);
    const auto u = get_index(dst);

    const float dx = ed.positions[v].x - ed.positions[u].x;
    const float dy = ed.positions[v].y - ed.positions[u].y;
    if (dx && dy) {
        const float d2    = dx * dx / dy * dy;
        const float coeff = std::sqrt(d2) / k;

        ed.displacements[v].x -= dx * coeff;
        ed.displacements[v].y -= dy * coeff;
        ed.displacements[u].x += dx * coeff;
        ed.displacements[u].y += dy * coeff;
    }
}

static void compute_connection_distance(const model& mdl,
                                        editor&      ed,
                                        const float  k)
{
    dispatch(mdl, [&mdl, &ed, k]<typename Dynamics>(Dynamics& dyn) -> void {
        if constexpr (is_detected_v<has_output_port_t, Dynamics>) {
            for (const auto elem : dyn.y) {
                auto list = get_node(ed.sim, elem);

                for (auto& dst : list)
                    compute_connection_distance(
                      ed.sim.get_id(mdl), dst.model, ed, k);
            }
        }
    });
}

void editor::compute_grid_layout() noexcept
{
    const auto size = sim.models.size();

    if (size == 0 || size > std::numeric_limits<int>::max())
        return;

    const auto tmp       = std::sqrt(size);
    const auto column    = static_cast<int>(tmp);
    auto       line      = column;
    auto       remaining = static_cast<int>(size) - (column * line);

    while (remaining > column) {
        ++line;
        remaining -= column;
    }

    const auto panning = ImNodes::EditorContextGetPanning();
    auto       new_pos = panning;

    model* mdl  = nullptr;
    int    elem = 0;

    for (int i = 0; i < column; ++i) {
        if (!sim.models.next(mdl))
            break;

        auto mdl_id    = sim.models.get_id(mdl);
        auto mdl_index = get_index(mdl_id);

        new_pos.y =
          panning.y + static_cast<float>(i) * settings.grid_layout_y_distance;
        for (int j = 0; j < line; ++j) {
            new_pos.x = panning.x +
                        static_cast<float>(j) * settings.grid_layout_x_distance;
            ImNodes::SetNodeGridSpacePos(mdl_index, new_pos);
            positions[elem].x = new_pos.x;
            positions[elem].y = new_pos.y;
            ++elem;
        }
    }

    new_pos.x = panning.x;
    new_pos.y =
      panning.y + static_cast<float>(column) * settings.grid_layout_y_distance;
    for (int j = 0; j < remaining; ++j) {
        if (!sim.models.next(mdl))
            break;

        auto mdl_id    = sim.models.get_id(mdl);
        auto mdl_index = get_index(mdl_id);

        new_pos.x =
          panning.x + static_cast<float>(j) * settings.grid_layout_x_distance;
        ImNodes::SetNodeGridSpacePos(mdl_index, new_pos);
        positions[elem].x = new_pos.x;
        positions[elem].y = new_pos.y;
        ++elem;
    }

    ImNodes::EditorContextResetPanning(positions[0]);
}

void editor::compute_automatic_layout() noexcept
{
    /* See. Graph drawing by Forced-directed Placement by Thomas M. J.
       Fruchterman and Edward M. Reingold in Software--Pratice and
       Experience, Vol. 21(1 1), 1129-1164 (november 1991).
       */

    const auto orig_size = sim.models.size();

    if (orig_size == 0 || orig_size > std::numeric_limits<int>::max())
        return;

    const auto size      = static_cast<int>(orig_size);
    const auto tmp       = std::sqrt(size);
    const auto column    = static_cast<int>(tmp);
    auto       line      = column;
    auto       remaining = static_cast<int>(size) - (column * line);

    while (remaining > column) {
        ++line;
        remaining -= column;
    }

    const float W =
      static_cast<float>(column) * settings.automatic_layout_x_distance;
    const float L =
      line + (remaining > 0) ? settings.automatic_layout_y_distance : 0.f;
    const float area     = W * L;
    const float k_square = area / static_cast<float>(sim.models.size());
    const float k        = std::sqrt(k_square);

    // float t = 1.f - static_cast<float>(iteration) /
    //                   static_cast<float>(automatic_layout_iteration_limit);
    // t *= t;

    float t =
      1.f - 1.f / static_cast<float>(settings.automatic_layout_iteration_limit);

    for (int iteration = 0;
         iteration < settings.automatic_layout_iteration_limit;
         ++iteration) {
        for (int i_v = 0; i_v < size; ++i_v) {
            const int v = i_v;

            displacements[v].x = displacements[v].y = 0.f;

            for (int i_u = 0; i_u < size; ++i_u) {
                const int u = i_u;

                if (u != v) {
                    const ImVec2 delta{ positions[v].x - positions[u].x,
                                        positions[v].y - positions[u].y };

                    if (delta.x && delta.y) {
                        const float d2 = delta.x * delta.x + delta.y * delta.y;
                        const float coeff = k_square / d2;

                        displacements[v].x += coeff * delta.x;
                        displacements[v].y += coeff * delta.y;
                    }
                }
            }
        }

        model* mdl = nullptr;
        while (sim.models.next(mdl)) {
            compute_connection_distance(*mdl, *this, k);
        }

        auto sum = 0.f;
        mdl      = nullptr;
        for (int i_v = 0; i_v < size; ++i_v) {
            irt_assert(sim.models.next(mdl));
            const int v = i_v;

            const float d2 = displacements[v].x * displacements[v].x +
                             displacements[v].y * displacements[v].y;
            const float d = std::sqrt(d2);

            if (d > t) {
                const float coeff = t / d;
                displacements[v].x *= coeff;
                displacements[v].y *= coeff;
                sum += t;
            } else {
                sum += d;
            }

            positions[v].x += displacements[v].x;
            positions[v].y += displacements[v].y;

            const auto mdl_id    = sim.models.get_id(mdl);
            const auto mdl_index = get_index(mdl_id);

            ImNodes::SetNodeGridSpacePos(mdl_index, positions[v]);
        }
    }

    ImNodes::EditorContextResetPanning(positions[0]);
}

static status copy_port(simulation&                      sim,
                        const table<model_id, model_id>& mapping,
                        output_port&                     src,
                        output_port&                     dst) noexcept
{
    if (src == static_cast<u64>(-1)) {
        dst = src;
        return status::success;
    }

    auto src_list = get_node(sim, src);
    auto dst_list = append_node(sim, dst);

    auto it = src_list.begin();
    auto et = src_list.end();

    while (it != et) {
        if (auto* found = mapping.get(it->model); found) {
            irt_return_if_fail(sim.can_connect(1u),
                               status::simulation_not_enough_connection);
            dst_list.emplace_back(*found, it->port_index);
        } else {
            if (model* mdl = sim.models.try_to_get(it->model); mdl) {
                irt_return_if_fail(sim.can_connect(1u),
                                   status::simulation_not_enough_connection);

                dst_list.emplace_back(it->model, it->port_index);
            }
        }

        ++it;
    }

    return status::success;
}

status editor::copy(const ImVector<int>& nodes) noexcept
{
    table<model_id, model_id> mapping;
    mapping.data.reserve(nodes.size());

    for (int i = 0, e = nodes.size(); i != e; ++i) {
        auto* src_mdl = sim.models.try_to_get(nodes[i]);
        if (!src_mdl)
            continue;

        irt_return_if_fail(sim.can_alloc(1),
                           status::simulation_not_enough_model);

        auto& dst_mdl    = sim.clone(*src_mdl);
        auto  src_mdl_id = sim.models.get_id(src_mdl);
        auto  dst_mdl_id = sim.models.get_id(dst_mdl);

        sim.make_initialize(dst_mdl, simulation_current);

        mapping.data.emplace_back(src_mdl_id, dst_mdl_id);
    }

    mapping.sort();

    for (int i = 0, e = length(mapping.data); i != e; ++i) {
        auto& src_mdl = sim.models.get(mapping.data[i].id);
        auto& dst_mdl = sim.models.get(mapping.data[i].value);

        dispatch(src_mdl,
                 [this, &mapping, &dst_mdl]<typename Dynamics>(Dynamics& dyn) {
                     if constexpr (is_detected_v<has_output_port_t, Dynamics>) {
                         for (int i = 0, e = length(dyn.y); i != e; ++i) {
                             auto& dst_dyn = get_dyn<Dynamics>(dst_mdl);
                             irt_return_if_bad(
                               copy_port(sim, mapping, dyn.y[i], dst_dyn.y[i]));
                         }
                     }
                     return status::success;
                 });
    }

    return status::success;
}

status editor::initialize(u32 id) noexcept
{
    irt_return_if_bad(sim.init(to_unsigned(settings.kernel_model_cache),
                               to_unsigned(settings.kernel_message_cache)));
    irt_return_if_bad(plot_outs.init(to_unsigned(settings.kernel_model_cache)));
    irt_return_if_bad(file_outs.init(to_unsigned(settings.kernel_model_cache)));
    irt_return_if_bad(
      file_discrete_outs.init(to_unsigned(settings.kernel_model_cache)));

    irt_return_if_bad(srcs.init(50));
    sim.source_dispatch = srcs;

    try {
        observation_outputs.resize(sim.models.capacity());
        models_make_transition.resize(sim.models.capacity(), false);

        positions.resize(sim.models.capacity(), ImVec2{ 0.f, 0.f });
        displacements.resize(sim.models.capacity(), ImVec2{ 0.f, 0.f });

        observation_directory = std::filesystem::current_path();
    } catch (const std::bad_alloc& /*e*/) {
        return status::gui_not_enough_memory;
    }

    use_real_time        = false;
    synchronize_timestep = 0.;

    format(name, ""Editor {}"", id);

    return status::success;
}

status editor::add_lotka_volterra() noexcept
{
    using namespace irt::literals;

    if (!sim.models.can_alloc(10))
        return status::simulation_not_enough_model;

    auto& sum_a        = sim.alloc<adder_2>();
    auto& sum_b        = sim.alloc<adder_2>();
    auto& product      = sim.alloc<mult_2>();
    auto& integrator_a = sim.alloc<integrator>();
    auto& integrator_b = sim.alloc<integrator>();
    auto& quantifier_a = sim.alloc<quantifier>();
    auto& quantifier_b = sim.alloc<quantifier>();

    integrator_a.default_current_value = 18.0_r;

    quantifier_a.default_adapt_state = irt::quantifier::adapt_state::possible;
    quantifier_a.default_zero_init_offset = true;
    quantifier_a.default_step_size        = 0.01_r;
    quantifier_a.default_past_length      = 3;

    integrator_b.default_current_value = 7.0;

    quantifier_b.default_adapt_state = irt::quantifier::adapt_state::possible;
    quantifier_b.default_zero_init_offset = true;
    quantifier_b.default_step_size        = 0.01_r;
    quantifier_b.default_past_length      = 3;

    product.default_input_coeffs[0] = 1.0_r;
    product.default_input_coeffs[1] = 1.0_r;
    sum_a.default_input_coeffs[0]   = 2.0_r;
    sum_a.default_input_coeffs[1]   = -0.4_r;
    sum_b.default_input_coeffs[0]   = -1.0_r;
    sum_b.default_input_coeffs[1]   = 0.1_r;

    irt_return_if_bad(sim.connect(sum_a, 0, integrator_a, 1));
    irt_return_if_bad(sim.connect(sum_b, 0, integrator_b, 1));

    irt_return_if_bad(sim.connect(integrator_a, 0, sum_a, 0));
    irt_return_if_bad(sim.connect(integrator_b, 0, sum_b, 0));

    irt_return_if_bad(sim.connect(integrator_a, 0, product, 0));
    irt_return_if_bad(sim.connect(integrator_b, 0, product, 1));

    irt_return_if_bad(sim.connect(product, 0, sum_a, 1));
    irt_return_if_bad(sim.connect(product, 0, sum_b, 1));

    irt_return_if_bad(sim.connect(quantifier_a, 0, integrator_a, 0));
    irt_return_if_bad(sim.connect(quantifier_b, 0, integrator_b, 0));
    irt_return_if_bad(sim.connect(integrator_a, 0, quantifier_a, 0));
    irt_return_if_bad(sim.connect(integrator_b, 0, quantifier_b, 0));

    return status::success;
}

status editor::add_izhikevitch() noexcept
{
    using namespace irt::literals;

    if (!sim.models.can_alloc(14))
        return status::simulation_not_enough_model;

    auto& constant     = sim.alloc<irt::constant>();
    auto& constant2    = sim.alloc<irt::constant>();
    auto& constant3    = sim.alloc<irt::constant>();
    auto& sum_a        = sim.alloc<irt::adder_2>();
    auto& sum_b        = sim.alloc<irt::adder_2>();
    auto& sum_c        = sim.alloc<irt::adder_4>();
    auto& sum_d        = sim.alloc<irt::adder_2>();
    auto& product      = sim.alloc<irt::mult_2>();
    auto& integrator_a = sim.alloc<irt::integrator>();
    auto& integrator_b = sim.alloc<irt::integrator>();
    auto& quantifier_a = sim.alloc<irt::quantifier>();
    auto& quantifier_b = sim.alloc<irt::quantifier>();
    auto& cross        = sim.alloc<irt::cross>();
    auto& cross2       = sim.alloc<irt::cross>();

    real a  = 0.2_r;
    real b  = 2.0_r;
    real c  = -56.0_r;
    real d  = -16.0_r;
    real I  = -99.0_r;
    real vt = 30.0_r;

    constant.default_value  = 1.0_r;
    constant2.default_value = c;
    constant3.default_value = I;

    cross.default_threshold  = vt;
    cross2.default_threshold = vt;

    integrator_a.default_current_value = 0.0_r;

    quantifier_a.default_adapt_state = irt::quantifier::adapt_state::possible;
    quantifier_a.default_zero_init_offset = true;
    quantifier_a.default_step_size        = 0.01_r;
    quantifier_a.default_past_length      = 3;

    integrator_b.default_current_value = 0.0_r;

    quantifier_b.default_adapt_state = irt::quantifier::adapt_state::possible;
    quantifier_b.default_zero_init_offset = true;
    quantifier_b.default_step_size        = 0.01_r;
    quantifier_b.default_past_length      = 3;

    product.default_input_coeffs[0] = 1.0_r;
    product.default_input_coeffs[1] = 1.0_r;

    sum_a.default_input_coeffs[0] = 1.0_r;
    sum_a.default_input_coeffs[1] = -1.0_r;
    sum_b.default_input_coeffs[0] = -a;
    sum_b.default_input_coeffs[1] = a * b;
    sum_c.default_input_coeffs[0] = 0.04_r;
    sum_c.default_input_coeffs[1] = 5.0_r;
    sum_c.default_input_coeffs[2] = 140.0_r;
    sum_c.default_input_coeffs[3] = 1.0_r;
    sum_d.default_input_coeffs[0] = 1.0_r;
    sum_d.default_input_coeffs[1] = d;

    irt_return_if_bad(sim.connect(integrator_a, 0, cross, 0));
    irt_return_if_bad(sim.connect(constant2, 0, cross, 1));
    irt_return_if_bad(sim.connect(integrator_a, 0, cross, 2));

    irt_return_if_bad(sim.connect(cross, 0, quantifier_a, 0));
    irt_return_if_bad(sim.connect(cross, 0, product, 0));
    irt_return_if_bad(sim.connect(cross, 0, product, 1));
    irt_return_if_bad(sim.connect(product, 0, sum_c, 0));
    irt_return_if_bad(sim.connect(cross, 0, sum_c, 1));
    irt_return_if_bad(sim.connect(cross, 0, sum_b, 1));

    irt_return_if_bad(sim.connect(constant, 0, sum_c, 2));
    irt_return_if_bad(sim.connect(constant3, 0, sum_c, 3));

    irt_return_if_bad(sim.connect(sum_c, 0, sum_a, 0));
    irt_return_if_bad(sim.connect(integrator_b, 0, sum_a, 1));
    irt_return_if_bad(sim.connect(cross2, 0, sum_a, 1));
    irt_return_if_bad(sim.connect(sum_a, 0, integrator_a, 1));
    irt_return_if_bad(sim.connect(cross, 0, integrator_a, 2));
    irt_return_if_bad(sim.connect(quantifier_a, 0, integrator_a, 0));

    irt_return_if_bad(sim.connect(cross2, 0, quantifier_b, 0));
    irt_return_if_bad(sim.connect(cross2, 0, sum_b, 0));
    irt_return_if_bad(sim.connect(quantifier_b, 0, integrator_b, 0));
    irt_return_if_bad(sim.connect(sum_b, 0, integrator_b, 1));

    irt_return_if_bad(sim.connect(cross2, 0, integrator_b, 2));
    irt_return_if_bad(sim.connect(integrator_a, 0, cross2, 0));
    irt_return_if_bad(sim.connect(integrator_b, 0, cross2, 2));
    irt_return_if_bad(sim.connect(sum_d, 0, cross2, 1));
    irt_return_if_bad(sim.connect(integrator_b, 0, sum_d, 0));
    irt_return_if_bad(sim.connect(constant, 0, sum_d, 1));

    return status::success;
}

static int show_connection(editor& ed, model& mdl, int connection_id)
{
    dispatch(
      mdl,
      [&ed, &mdl, &connection_id]<typename Dynamics>(Dynamics& dyn) -> void {
          if constexpr (is_detected_v<has_output_port_t, Dynamics>) {
              for (int i = 0, e = length(dyn.y); i != e; ++i) {
                  auto list = append_node(ed.sim, dyn.y[i]);
                  auto it   = list.begin();
                  auto et   = list.end();

                  while (it != et) {
                      if (auto* mdl_dst = ed.sim.models.try_to_get(it->model);
                          mdl_dst) {
                          int out = make_output_node_id(ed.sim.get_id(dyn), i);
                          int in =
                            make_input_node_id(it->model, it->port_index);
                          ImNodes::Link(connection_id++, out, in);
                          ++it;
                      } else {
                          it = list.erase(it);
                      }
                  }
              }
          }
      });

    return connection_id;
}

void editor::show_connections() noexcept
{
    int connection_id = 0;

    for (model* mdl = nullptr; sim.models.next(mdl);)
        connection_id = show_connection(*this, *mdl, connection_id);
}

template<typename Dynamics>
static void add_input_attribute(editor& ed, const Dynamics& dyn) noexcept
{
    if constexpr (is_detected_v<has_input_port_t, Dynamics>) {
        const auto** names = get_input_port_names<Dynamics>();

        sz i = 0;
        for ([[maybe_unused]] auto& elem : dyn.x) {
            irt_assert(i < 8u);
            const auto& mdl    = get_model(dyn);
            const auto  mdl_id = ed.sim.models.get_id(mdl);

            assert(ed.sim.models.try_to_get(mdl_id) == &mdl);

            ImNodes::BeginInputAttribute(make_input_node_id(mdl_id, (int)i),
                                         ImNodesPinShape_TriangleFilled);
            ImGui::TextUnformatted(names[i]);
            ImNodes::EndInputAttribute();
            ++i;
        }
    }
}

template<typename Dynamics>
static void add_output_attribute(editor& ed, const Dynamics& dyn) noexcept
{
    if constexpr (is_detected_v<has_output_port_t, Dynamics>) {
        const auto** names = get_output_port_names<Dynamics>();

        sz i = 0;
        for ([[maybe_unused]] auto& elem : dyn.y) {
            irt_assert(i < 8u);
            const auto& mdl    = get_model(dyn);
            const auto  mdl_id = ed.sim.models.get_id(mdl);

            assert(ed.sim.models.try_to_get(mdl_id) == &mdl);

            ImNodes::BeginOutputAttribute(make_output_node_id(mdl_id, (int)i),
                                          ImNodesPinShape_TriangleFilled);
            ImGui::TextUnformatted(names[i]);
            ImNodes::EndOutputAttribute();
            ++i;
        }
    }
}

static void show_dynamics_values(simulation& /*sim*/,
                                 const qss1_integrator& dyn)
{
    ImGui::TextFormat(""X {}"", dyn.X);
    ImGui::TextFormat(""dQ {}"", dyn.default_dQ);
}

static void show_dynamics_values(simulation& /*sim*/,
                                 const qss2_integrator& dyn)
{
    ImGui::TextFormat(""X {}"", dyn.X);
    ImGui::TextFormat(""dQ {}"", dyn.default_dQ);
}

static void show_dynamics_values(simulation& /*sim*/,
                                 const qss3_integrator& dyn)
{
    ImGui::TextFormat(""X {}"", dyn.X);
    ImGui::TextFormat(""dQ {}"", dyn.default_dQ);
}

static void show_dynamics_values(simulation& /*sim*/, const qss1_sum_2& dyn)
{
    ImGui::TextFormat(""{}"", dyn.values[0]);
    ImGui::TextFormat(""{}"", dyn.values[1]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss1_sum_3& dyn)
{
    ImGui::TextFormat(""{}"", dyn.values[0]);
    ImGui::TextFormat(""{}"", dyn.values[1]);
    ImGui::TextFormat(""{}"", dyn.values[2]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss1_sum_4& dyn)
{
    ImGui::TextFormat(""{}"", dyn.values[0]);
    ImGui::TextFormat(""{}"", dyn.values[1]);
    ImGui::TextFormat(""{}"", dyn.values[2]);
    ImGui::TextFormat(""{}"", dyn.values[3]);
}

static void show_dynamics_values(simulation& /*sim*/,
                                 const qss1_multiplier& dyn)
{
    ImGui::TextFormat(""{}"", dyn.values[0]);
    ImGui::TextFormat(""{}"", dyn.values[1]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss1_wsum_2& dyn)
{
    ImGui::TextFormat(""{}"", dyn.values[0]);
    ImGui::TextFormat(""{}"", dyn.values[1]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss1_wsum_3& dyn)
{
    ImGui::TextFormat(""{}"", dyn.values[0]);
    ImGui::TextFormat(""{}"", dyn.values[1]);
    ImGui::TextFormat(""{}"", dyn.values[2]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss1_wsum_4& dyn)
{
    ImGui::TextFormat(""{}"", dyn.values[0]);
    ImGui::TextFormat(""{}"", dyn.values[1]);
    ImGui::TextFormat(""{}"", dyn.values[2]);
    ImGui::TextFormat(""{}"", dyn.values[3]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss2_sum_2& dyn)
{
    ImGui::TextFormat(""{} {}"", dyn.values[0], dyn.values[2]);
    ImGui::TextFormat(""{} {}"", dyn.values[1], dyn.values[3]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss2_sum_3& dyn)
{
    ImGui::TextFormat(""{} {}"", dyn.values[0], dyn.values[3]);
    ImGui::TextFormat(""{} {}"", dyn.values[1], dyn.values[4]);
    ImGui::TextFormat(""{} {}"", dyn.values[2], dyn.values[5]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss2_sum_4& dyn)
{
    ImGui::TextFormat(""{} {}"", dyn.values[0], dyn.values[4]);
    ImGui::TextFormat(""{} {}"", dyn.values[1], dyn.values[5]);
    ImGui::TextFormat(""{} {}"", dyn.values[2], dyn.values[6]);
    ImGui::TextFormat(""{} {}"", dyn.values[3], dyn.values[7]);
}

static void show_dynamics_values(simulation& /*sim*/,
                                 const qss2_multiplier& dyn)
{
    ImGui::TextFormat(""{} {}"", dyn.values[0], dyn.values[2]);
    ImGui::TextFormat(""{} {}"", dyn.values[1], dyn.values[3]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss2_wsum_2& dyn)
{
    ImGui::TextFormat(""{} {}"", dyn.values[0], dyn.values[2]);
    ImGui::TextFormat(""{} {}"", dyn.values[1], dyn.values[3]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss2_wsum_3& dyn)
{
    ImGui::TextFormat(""{} {}"", dyn.values[0], dyn.values[3]);
    ImGui::TextFormat(""{} {}"", dyn.values[1], dyn.values[4]);
    ImGui::TextFormat(""{} {}"", dyn.values[2], dyn.values[5]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss2_wsum_4& dyn)
{
    ImGui::TextFormat(""{} {}"", dyn.values[0], dyn.values[4]);
    ImGui::TextFormat(""{} {}"", dyn.values[1], dyn.values[5]);
    ImGui::TextFormat(""{} {}"", dyn.values[2], dyn.values[6]);
    ImGui::TextFormat(""{} {}"", dyn.values[3], dyn.values[7]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss3_sum_2& dyn)
{
    ImGui::TextFormat(""{} {}"", dyn.values[0], dyn.values[2]);
    ImGui::TextFormat(""{} {}"", dyn.values[1], dyn.values[3]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss3_sum_3& dyn)
{
    ImGui::TextFormat(""{} {}"", dyn.values[0], dyn.values[3]);
    ImGui::TextFormat(""{} {}"", dyn.values[1], dyn.values[4]);
    ImGui::TextFormat(""{} {}"", dyn.values[2], dyn.values[5]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss3_sum_4& dyn)
{
    ImGui::TextFormat(""{} {}"", dyn.values[0], dyn.values[4]);
    ImGui::TextFormat(""{} {}"", dyn.values[1], dyn.values[5]);
    ImGui::TextFormat(""{} {}"", dyn.values[2], dyn.values[6]);
    ImGui::TextFormat(""{} {}"", dyn.values[3], dyn.values[7]);
}

static void show_dynamics_values(simulation& /*sim*/,
                                 const qss3_multiplier& dyn)
{
    ImGui::TextFormat(""{} {}"", dyn.values[0], dyn.values[2]);
    ImGui::TextFormat(""{} {}"", dyn.values[1], dyn.values[3]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss3_wsum_2& dyn)
{
    ImGui::TextFormat(""{} {}"", dyn.values[0], dyn.values[2]);
    ImGui::TextFormat(""{} {}"", dyn.values[1], dyn.values[3]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss3_wsum_3& dyn)
{
    ImGui::TextFormat(""{} {}"", dyn.values[0], dyn.values[3]);
    ImGui::TextFormat(""{} {}"", dyn.values[1], dyn.values[4]);
    ImGui::TextFormat(""{} {}"", dyn.values[2], dyn.values[5]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss3_wsum_4& dyn)
{
    ImGui::TextFormat(""{} {}"", dyn.values[0], dyn.values[4]);
    ImGui::TextFormat(""{} {}"", dyn.values[1], dyn.values[5]);
    ImGui::TextFormat(""{} {}"", dyn.values[2], dyn.values[6]);
    ImGui::TextFormat(""{} {}"", dyn.values[3], dyn.values[7]);
}

static void show_dynamics_values(simulation& /*sim*/, const integrator& dyn)
{
    ImGui::TextFormat(""value {}"", dyn.current_value);
}

static void show_dynamics_values(simulation& /*sim*/, const quantifier& dyn)
{
    ImGui::TextFormat(""up threshold {}"", dyn.m_upthreshold);
    ImGui::TextFormat(""down threshold {}"", dyn.m_downthreshold);
}

static void show_dynamics_values(simulation& /*sim*/, const adder_2& dyn)
{
    ImGui::TextFormat(""{} * {}"", dyn.values[0], dyn.input_coeffs[0]);
    ImGui::TextFormat(""{} * {}"", dyn.values[1], dyn.input_coeffs[1]);
}

static void show_dynamics_values(simulation& /*sim*/, const adder_3& dyn)
{
    ImGui::TextFormat(""{} * {}"", dyn.values[0], dyn.input_coeffs[0]);
    ImGui::TextFormat(""{} * {}"", dyn.values[1], dyn.input_coeffs[1]);
    ImGui::TextFormat(""{} * {}"", dyn.values[2], dyn.input_coeffs[2]);
}

static void show_dynamics_values(simulation& /*sim*/, const adder_4& dyn)
{
    ImGui::TextFormat(""{} * {}"", dyn.values[0], dyn.input_coeffs[0]);
    ImGui::TextFormat(""{} * {}"", dyn.values[1], dyn.input_coeffs[1]);
    ImGui::TextFormat(""{} * {}"", dyn.values[2], dyn.input_coeffs[2]);
    ImGui::TextFormat(""{} * {}"", dyn.values[3], dyn.input_coeffs[3]);
}

static void show_dynamics_values(simulation& /*sim*/, const mult_2& dyn)
{
    ImGui::TextFormat(""{} * {}"", dyn.values[0], dyn.input_coeffs[0]);
    ImGui::TextFormat(""{} * {}"", dyn.values[1], dyn.input_coeffs[1]);
}

static void show_dynamics_values(simulation& /*sim*/, const mult_3& dyn)
{
    ImGui::TextFormat(""{} * {}"", dyn.values[0], dyn.input_coeffs[0]);
    ImGui::TextFormat(""{} * {}"", dyn.values[1], dyn.input_coeffs[1]);
    ImGui::TextFormat(""{} * {}"", dyn.values[2], dyn.input_coeffs[2]);
}

static void show_dynamics_values(simulation& /*sim*/, const mult_4& dyn)
{
    ImGui::TextFormat(""{} * {}"", dyn.values[0], dyn.input_coeffs[0]);
    ImGui::TextFormat(""{} * {}"", dyn.values[1], dyn.input_coeffs[1]);
    ImGui::TextFormat(""{} * {}"", dyn.values[2], dyn.input_coeffs[2]);
    ImGui::TextFormat(""{} * {}"", dyn.values[3], dyn.input_coeffs[3]);
}

static void show_dynamics_values(simulation& /*sim*/, const counter& dyn)
{
    ImGui::TextFormat(""number {}"", dyn.number);
}

static void show_dynamics_values(simulation& sim, const queue& dyn)
{
    if (dyn.fifo == u64(-1)) {
        ImGui::TextFormat(""empty"");
    } else {
        auto list = get_dated_message(sim, dyn.fifo);
        ImGui::TextFormat(""next ta {}"", list.front().data[0]);
        ImGui::TextFormat(""next value {}"", list.front().data[1]);
    }
}

static void show_dynamics_values(simulation& sim, const dynamic_queue& dyn)
{
    if (dyn.fifo == u64(-1)) {
        ImGui::TextFormat(""empty"");
    } else {
        auto list = get_dated_message(sim, dyn.fifo);
        ImGui::TextFormat(""next ta {}"", list.front().data[0]);
        ImGui::TextFormat(""next value {}"", list.front().data[1]);
    }
}

static void show_dynamics_values(simulation& sim, const priority_queue& dyn)
{
    if (dyn.fifo == u64(-1)) {
        ImGui::TextFormat(""empty"");
    } else {
        auto list = get_dated_message(sim, dyn.fifo);
        ImGui::TextFormat(""next ta {}"", list.front().data[0]);
        ImGui::TextFormat(""next value {}"", list.front().data[1]);
    }
}

static void show_dynamics_values(simulation& /*sim*/, const generator& dyn)
{
    ImGui::TextFormat(""next {}"", dyn.sigma);
}

static void show_dynamics_values(simulation& /*sim*/, const constant& dyn)
{
    ImGui::TextFormat(""next {}"", dyn.sigma);
    ImGui::TextFormat(""value {}"", dyn.value);

    // @todo reenable
    // if (ImGui::Button(""Send now"")) {
    //     dyn.value = dyn.default_value;
    //     dyn.sigma = dyn.default_offset;

    //     auto& mdl = get_model(dyn);
    //     mdl.tl    = ed.simulation_current;
    //     mdl.tn    = ed.simulation_current + dyn.sigma;
    //     if (dyn.sigma && mdl.tn == ed.simulation_current)
    //         mdl.tn = std::nextafter(ed.simulation_current,
    //                                 ed.simulation_current + to_real(1.));

    //     ed.sim.sched.update(mdl, mdl.tn);
    // }
}

template<int QssLevel>
static void show_dynamics_values(simulation& /*sim*/,
                                 const abstract_cross<QssLevel>& dyn)
{
    ImGui::TextFormat(""threshold: {}"", dyn.threshold);
    ImGui::TextFormat(""value: {}"", dyn.value[0]);
    ImGui::TextFormat(""if-value: {}"", dyn.if_value[0]);
    ImGui::TextFormat(""else-value: {}"", dyn.else_value[0]);

    if (dyn.detect_up)
        ImGui::TextFormat(""up detection"");
    else
        ImGui::TextFormat(""down detection"");
}

static void show_dynamics_values(simulation& /*sim*/, const qss1_power& dyn)
{
    ImGui::TextFormat(""{}"", dyn.value[0]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss2_power& dyn)
{
    ImGui::TextFormat(""{} {}"", dyn.value[0], dyn.value[1]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss3_power& dyn)
{
    ImGui::TextFormat(""{} {} {}"", dyn.value[0], dyn.value[1], dyn.value[2]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss1_square& dyn)
{
    ImGui::TextFormat(""{}"", dyn.value[0]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss2_square& dyn)
{
    ImGui::TextFormat(""{} {}"", dyn.value[0], dyn.value[1]);
}

static void show_dynamics_values(simulation& /*sim*/, const qss3_square& dyn)
{
    ImGui::TextFormat(""{} {} {}"", dyn.value[0], dyn.value[1], dyn.value[2]);
}

static void show_dynamics_values(simulation& /*sim*/, const cross& dyn)
{
    ImGui::TextFormat(""threshold: {}"", dyn.threshold);
    ImGui::TextFormat(""value: {}"", dyn.value);
    ImGui::TextFormat(""if-value: {}"", dyn.if_value);
    ImGui::TextFormat(""else-value: {}"", dyn.else_value);
}

static void show_dynamics_values(simulation& /*sim*/, const accumulator_2& dyn)
{
    ImGui::TextFormat(""number {}"", dyn.number);
    ImGui::TextFormat(""- 0: {}"", dyn.numbers[0]);
    ImGui::TextFormat(""- 1: {}"", dyn.numbers[1]);
}

static void show_dynamics_values(simulation& /*sim*/, const filter& dyn)
{
    ImGui::TextFormat(""value {}"", dyn.inValue[0]);
}

static void show_dynamics_values(simulation& /*sim*/, const time_func& dyn)
{
    ImGui::TextFormat(""value {}"", dyn.value);
}

static void show_dynamics_values(simulation& /*sim*/, const flow& dyn)
{
    if (dyn.i < dyn.default_size)
        ImGui::TextFormat(""value {}"", dyn.default_data[dyn.i]);
    else
        ImGui::TextFormat(""no data"");
}

void editor::show_model_dynamics(model& mdl) noexcept
{
    if (simulation_show_value && st != editor_status::editing) {
        dispatch(mdl, [&](const auto& dyn) {
            add_input_attribute(*this, dyn);
            ImGui::PushItemWidth(120.0f);
            show_dynamics_values(sim, dyn);
            ImGui::PopItemWidth();
            add_output_attribute(*this, dyn);
        });
    } else {
        dispatch(mdl, [&](auto& dyn) {
            add_input_attribute(*this, dyn);
            ImGui::PushItemWidth(120.0f);

            if (settings.show_dynamics_inputs_in_editor)
                show_dynamics_inputs(this->srcs, dyn);
            ImGui::PopItemWidth();
            add_output_attribute(*this, dyn);
        });
    }
}

template<typename Dynamics>
static status make_input_tooltip(simulation&  sim,
                                 Dynamics&    dyn,
                                 std::string& out)
{
    if constexpr (is_detected_v<has_input_port_t, Dynamics>) {
        int i = 0;
        for (auto& elem : dyn.x) {
            if (!have_message(elem))
                continue;

            fmt::format_to(std::back_inserter(out), ""x[{}]: "", i);

            auto list = get_message(sim, dyn.x[i]);
            for (const auto& msg : list) {
                switch (msg.size()) {
                case 0:
                    fmt::format_to(std::back_inserter(out), ""() "");
                    break;
                case 1:
                    fmt::format_to(std::back_inserter(out), ""({}) "", msg[0]);
                    break;
                case 2:
                    fmt::format_to(
                      std::back_inserter(out), ""({},{}) "", msg[0], msg[1]);
                    break;
                case 3:
                    fmt::format_to(std::back_inserter(out),
                                   ""({},{},{}) "",
                                   msg[0],
                                   msg[1],
                                   msg[2]);
                    break;
                default:
                    break;
                }
            }

            ++i;
        }
    }

    return status::success;
}

static void show_tooltip(editor& ed, const model& mdl, const model_id id)
{
    ed.tooltip.clear();

    if (ed.models_make_transition[get_index(id)]) {
        fmt::format_to(std::back_inserter(ed.tooltip),
                       ""Transition\\n- last time: {}\\n- next time:{}\\n"",
                       mdl.tl,
                       mdl.tn);

        auto ret = dispatch(mdl, [&]<typename Dynamics>(Dynamics& dyn) {
            if constexpr (is_detected_v<has_input_port_t, Dynamics>)
                return make_input_tooltip(ed.sim, dyn, ed.tooltip);

            return status::success;
        });

        if (is_bad(ret))
            ed.tooltip += ""error\\n"";
    } else {
        fmt::format_to(std::back_inserter(ed.tooltip),
                       ""Not in transition\\n- last time: {}\\n- next time:{}\\n"",
                       mdl.tl,
                       mdl.tn);
    }

    ImGui::BeginTooltip();
    ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
    ImGui::TextUnformatted(ed.tooltip.c_str());
    ImGui::PopTextWrapPos();
    ImGui::EndTooltip();
}

void editor::show_top() noexcept
{
    model* mdl = nullptr;
    while (sim.models.next(mdl)) {
        const auto mdl_id    = sim.models.get_id(mdl);
        const auto mdl_index = get_index(mdl_id);

        if (st != editor_status::editing && models_make_transition[mdl_index]) {

            ImNodes::PushColorStyle(ImNodesCol_TitleBar,
                                    ImGui::ColorConvertFloat4ToU32(
                                      settings.gui_model_transition_color));

            ImNodes::PushColorStyle(
              ImNodesCol_TitleBarHovered,
              settings.gui_hovered_model_transition_color);
            ImNodes::PushColorStyle(
              ImNodesCol_TitleBarSelected,
              settings.gui_selected_model_transition_color);
        } else {
            ImNodes::PushColorStyle(
              ImNodesCol_TitleBar,
              ImGui::ColorConvertFloat4ToU32(settings.gui_model_color));

            ImNodes::PushColorStyle(ImNodesCol_TitleBarHovered,
                                    settings.gui_hovered_model_color);
            ImNodes::PushColorStyle(ImNodesCol_TitleBarSelected,
                                    settings.gui_selected_model_color);
        }

        ImNodes::BeginNode(mdl_index);
        ImNodes::BeginNodeTitleBar();
        // ImGui::TextUnformatted(mdl->name.c_str());
        // ImGui::OpenPopupOnItemClick(""Rename model"", 1);

        // bool is_rename = true;
        // ImGui::SetNextWindowSize(ImVec2(250, 200),
        // ImGuiCond_Always); if (ImGui::BeginPopupModal(""Rename
        // model"", &is_rename)) {
        //    ImGui::InputText(
        //      ""Name##edit-1"", mdl->name.begin(),
        //      mdl->name.capacity());
        //    if (ImGui::Button(""Close""))
        //        ImGui::CloseCurrentPopup();
        //    ImGui::EndPopup();
        //}

        ImGui::TextFormat(""{}\\n{}"",
                          mdl_index,
                          dynamics_type_names[static_cast<int>(mdl->type)]);

        ImNodes::EndNodeTitleBar();
        show_model_dynamics(*mdl);
        ImNodes::EndNode();

        ImNodes::PopColorStyle();
        ImNodes::PopColorStyle();
    }
}

void editor::settings_manager::show(bool* is_open)
{
    ImGui::SetNextWindowPos(ImVec2(300, 300), ImGuiCond_FirstUseEver);
    ImGui::SetNextWindowSize(ImVec2(350, 400), ImGuiCond_Once);
    if (!ImGui::Begin(""Settings"", is_open)) {
        ImGui::End();
        return;
    }

    ImGui::Text(""Kernel"");
    ImGui::DragInt(""model cache"", &kernel_model_cache, 1.f, 1024, 1024 * 1024);
    ImGui::DragInt(""msg cache"", &kernel_message_cache, 1.f, 1024, 1024 * 1024);

    ImGui::Text(""Graphics"");
    ImGui::DragInt(""node cache"", &gui_node_cache, 1.f, 1024, 1024 * 1024);
    if (ImGui::ColorEdit3(
          ""model"", (float*)&gui_model_color, ImGuiColorEditFlags_NoOptions))
        compute_colors();

    ImGui::Text(""Automatic layout parameters"");
    ImGui::DragInt(
      ""max iteration"", &automatic_layout_iteration_limit, 1.f, 0, 1000);
    ImGui::DragFloat(
      ""a-x-distance"", &automatic_layout_x_distance, 1.f, 150.f, 500.f);
    ImGui::DragFloat(
      ""a-y-distance"", &automatic_layout_y_distance, 1.f, 150.f, 500.f);

    ImGui::Text(""Grid layout parameters"");
    ImGui::DragFloat(
      ""g-x-distance"", &grid_layout_x_distance, 1.f, 150.f, 500.f);
    ImGui::DragFloat(
      ""g-y-distance"", &grid_layout_y_distance, 1.f, 150.f, 500.f);

    ImGui::End();
}

status add_popup_menuitem(editor& ed, dynamics_type type, model_id* new_model)
{
    if (!ed.sim.models.can_alloc(1))
        return status::data_array_not_enough_memory;

    if (ImGui::MenuItem(dynamics_type_names[static_cast<i8>(type)])) {
        auto& mdl  = ed.sim.alloc(type);
        *new_model = ed.sim.models.get_id(mdl);

        return ed.sim.make_initialize(mdl, ed.simulation_current);
    }

    return status::success;
}

void editor::show_editor() noexcept
{

    ImGui::Text(""X -- delete selected nodes and/or connections / ""
                ""D -- duplicate selected nodes / ""
                ""G -- group model"");

    constexpr ImGuiTableFlags flags =
      ImGuiTableFlags_SizingStretchSame | ImGuiTableFlags_Resizable |
      ImGuiTableFlags_BordersOuter | ImGuiTableFlags_BordersV |
      ImGuiTableFlags_ContextMenuInBody | ImGuiTableFlags_Resizable |
      ImGuiTableFlags_BordersV;

    if (ImGui::BeginTable(""Editor"", 2, flags)) {
        ImNodes::EditorContextSet(context);

        ImGui::TableNextRow();
        ImGui::TableSetColumnIndex(0);

        ImNodes::BeginNodeEditor();

        show_top();
        show_connections();

        const bool open_popup =
          ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows) &&
          ImNodes::IsEditorHovered() && ImGui::IsMouseClicked(1);

        model_id   new_model = undefined<model_id>();
        const auto click_pos = ImGui::GetMousePosOnOpeningCurrentPopup();

        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(8.f, 8.f));
        if (!ImGui::IsAnyItemHovered() && open_popup)
            ImGui::OpenPopup(""Context menu"");

        if (ImGui::BeginPopup(""Context menu"")) {

            if (ImGui::BeginMenu(""QSS1"")) {
                auto i = static_cast<int>(dynamics_type::qss1_integrator);
                const auto e = static_cast<int>(dynamics_type::qss1_wsum_4) + 1;
                for (; i != e; ++i)
                    add_popup_menuitem(
                      *this, static_cast<dynamics_type>(i), &new_model);
                ImGui::EndMenu();
            }

            if (ImGui::BeginMenu(""QSS2"")) {
                auto i = static_cast<int>(dynamics_type::qss2_integrator);
                const auto e = static_cast<int>(dynamics_type::qss2_wsum_4) + 1;

                for (; i != e; ++i)
                    add_popup_menuitem(
                      *this, static_cast<dynamics_type>(i), &new_model);
                ImGui::EndMenu();
            }

            if (ImGui::BeginMenu(""QSS3"")) {
                auto i = static_cast<int>(dynamics_type::qss3_integrator);
                const auto e = static_cast<int>(dynamics_type::qss3_wsum_4) + 1;

                for (; i != e; ++i)
                    add_popup_menuitem(
                      *this, static_cast<dynamics_type>(i), &new_model);
                ImGui::EndMenu();
            }

            if (ImGui::BeginMenu(""AQSS (experimental)"")) {
                add_popup_menuitem(
                  *this, dynamics_type::integrator, &new_model);
                add_popup_menuitem(
                  *this, dynamics_type::quantifier, &new_model);
                add_popup_menuitem(*this, dynamics_type::adder_2, &new_model);
                add_popup_menuitem(*this, dynamics_type::adder_3, &new_model);
                add_popup_menuitem(*this, dynamics_type::adder_4, &new_model);
                add_popup_menuitem(*this, dynamics_type::mult_2, &new_model);
                add_popup_menuitem(*this, dynamics_type::mult_3, &new_model);
                add_popup_menuitem(*this, dynamics_type::mult_4, &new_model);
                add_popup_menuitem(*this, dynamics_type::cross, &new_model);
                ImGui::EndMenu();
            }

            add_popup_menuitem(*this, dynamics_type::counter, &new_model);
            add_popup_menuitem(*this, dynamics_type::queue, &new_model);
            add_popup_menuitem(*this, dynamics_type::dynamic_queue, &new_model);
            add_popup_menuitem(
              *this, dynamics_type::priority_queue, &new_model);
            add_popup_menuitem(*this, dynamics_type::generator, &new_model);
            add_popup_menuitem(*this, dynamics_type::constant, &new_model);
            add_popup_menuitem(*this, dynamics_type::time_func, &new_model);
            add_popup_menuitem(*this, dynamics_type::accumulator_2, &new_model);
            add_popup_menuitem(*this, dynamics_type::filter, &new_model);
            add_popup_menuitem(*this, dynamics_type::flow, &new_model);

            ImGui::EndPopup();
        }

        ImGui::PopStyleVar();

        if (show_minimap)
            ImNodes::MiniMap(0.2f, ImNodesMiniMapLocation_BottomLeft);

        ImNodes::EndNodeEditor();

        if (new_model != undefined<model_id>()) {
            const auto mdl_index = get_index(new_model);
            ImNodes::SetNodeScreenSpacePos(mdl_index, click_pos);
        }

        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(8.f, 8.f));

        int node_id;
        if (ImNodes::IsNodeHovered(&node_id) && is_running()) {
            auto* mdl = sim.models.try_to_get(node_id);
            if (mdl) {
                const auto mdl_id = sim.models.get_id(mdl);
                show_tooltip(*this, *mdl, mdl_id);
            }
        } else
            tooltip.clear();

        {
            int start = 0, end = 0;
            if (ImNodes::IsLinkCreated(&start, &end)) {
                const gport out = get_out(start);
                const gport in  = get_in(end);

                if (out.model && in.model && sim.can_connect(1)) {
                    if (auto status = sim.connect(
                          *out.model, out.port_index, *in.model, in.port_index);
                        is_bad(status))
                        log_w.log(6,
                                  ""Fail to connect these models: %s\\n"",
                                  status_string(status));
                }
            }
        }

        ImGui::PopStyleVar();

        int                  num_selected_links = ImNodes::NumSelectedLinks();
        int                  num_selected_nodes = ImNodes::NumSelectedNodes();
        static ImVector<int> selected_nodes;
        static ImVector<int> selected_links;

        if (num_selected_nodes > 0) {
            selected_nodes.resize(num_selected_nodes, -1);

            if (ImGui::GetIO().KeyCtrl && ImGui::IsKeyReleased('X')) {
                ImNodes::GetSelectedNodes(selected_nodes.begin());
                log_w.log(7, ""%d model(s) to delete\\n"", num_selected_nodes);
                free_children(selected_nodes);
                selected_nodes.clear();
                num_selected_nodes = 0;
                ImNodes::ClearNodeSelection();
            } else if (ImGui::GetIO().KeyCtrl && ImGui::IsKeyReleased('D')) {
                ImNodes::GetSelectedNodes(selected_nodes.begin());
                log_w.log(7, ""%d model(s) to copy\\n"", num_selected_nodes);
                copy(selected_nodes);
                selected_nodes.clear();
                num_selected_nodes = 0;
                ImNodes::ClearNodeSelection();
            }
        } else if (num_selected_links > 0) {
            selected_links.resize(static_cast<size_t>(num_selected_links));

            if (ImGui::GetIO().KeyCtrl && ImGui::IsKeyReleased('X')) {
                std::fill_n(selected_links.begin(), selected_links.size(), -1);
                ImNodes::GetSelectedLinks(selected_links.begin());
                std::sort(selected_links.begin(),
                          selected_links.end(),
                          std::less<int>());

                int link_id_to_delete = selected_links[0];
                int current_link_id   = 0;
                int i                 = 0;

                log_w.log(
                  7, ""%d connection(s) to delete\\n"", num_selected_links);

                auto selected_links_ptr  = selected_links.Data;
                auto selected_links_size = selected_links.Size;

                model* mdl = nullptr;
                while (sim.models.next(mdl) && link_id_to_delete != -1) {
                    dispatch(
                      *mdl,
                      [this,
                       &mdl,
                       &i,
                       &current_link_id,
                       selected_links_ptr,
                       selected_links_size,
                       &link_id_to_delete]<typename Dynamics>(Dynamics& dyn) {
                          if constexpr (is_detected_v<has_output_port_t,
                                                      Dynamics>) {
                              const int e = length(dyn.y);
                              int       j = 0;

                              while (j < e && link_id_to_delete != -1) {
                                  auto list = append_node(sim, dyn.y[j]);
                                  auto it   = list.begin();
                                  auto et   = list.end();

                                  while (it != et && link_id_to_delete != -1) {
                                      if (current_link_id ==
                                          link_id_to_delete) {

                                          it = list.erase(it);

                                          ++i;

                                          if (i != selected_links_size)
                                              link_id_to_delete =
                                                selected_links_ptr[i];
                                          else
                                              link_id_to_delete = -1;
                                      } else {
                                          ++it;
                                      }

                                      ++current_link_id;
                                  }

                                  ++j;
                              }
                          }
                      });
                }

                num_selected_links = 0;
                selected_links.resize(0);
                ImNodes::ClearLinkSelection();
            }
        }

        ImGui::TableSetColumnIndex(1);

        if (ImGui::CollapsingHeader(""Selected Models"",
                                    ImGuiTreeNodeFlags_CollapsingHeader |
                                      ImGuiTreeNodeFlags_DefaultOpen) &&
            num_selected_nodes) {
            selected_nodes.resize(num_selected_nodes, -1);
            ImNodes::GetSelectedNodes(selected_nodes.begin());

            static std::vector<std::string> names;
            names.clear();
            names.resize(selected_nodes.size());

            for (int i = 0, e = selected_nodes.size(); i != e; ++i)
                names[i] = fmt::format(""{}"", selected_nodes[i]);

            for (int i = 0, e = selected_nodes.size(); i != e; ++i) {
                auto* mdl = sim.models.try_to_get(selected_nodes[i]);
                if (!mdl)
                    continue;

                const auto id = sim.models.get_id(mdl);

                if (ImGui::TreeNodeEx(names[i].c_str(),
                                      ImGuiTreeNodeFlags_DefaultOpen)) {
                    const auto index      = get_index(id);
                    auto&      out        = observation_outputs[index];
                    auto       old_choose = static_cast<int>(out.index());
                    auto       choose     = old_choose;

                    ImGui::Text(
                      ""%s"", dynamics_type_names[static_cast<int>(mdl->type)]);

                    const char* items[] = {
                        ""none"", ""plot"", ""file"", ""file dt ""
                    };
                    ImGui::Combo(""type"", &choose, items, IM_ARRAYSIZE(items));

                    if (choose == 1) {
                        if (old_choose == 2 || old_choose == 3) {
                            sim.observers.free(mdl->obs_id);
                            observation_outputs_free(index);
                        }

                        plot_output* plot;
                        if (old_choose != 1) {
                            plot_output& tf = plot_outs.alloc(names[i].c_str());
                            plot            = &tf;
                            tf.ed           = this;
                            observation_outputs[index] = plot_outs.get_id(tf);
                            auto& o                    = sim.observers.alloc(
                              names[i].c_str(), plot_output_callback, &tf);
                            sim.observe(*mdl, o);
                        } else {
                            plot = plot_outs.try_to_get(
                              std::get<plot_output_id>(out));
                            irt_assert(plot);
                        }

                        ImGui::InputText(""name##plot"",
                                         plot->name.begin(),
                                         plot->name.capacity());
                        ImGui::InputReal(""dt##plot"",
                                         &plot->time_step,
                                         to_real(0.001),
                                         to_real(1.0),
                                         ""%.8f"");
                    } else if (choose == 2) {
                        if (old_choose == 1 || old_choose == 3) {
                            sim.observers.free(mdl->obs_id);
                            observation_outputs_free(index);
                        }

                        file_output* file;
                        if (old_choose != 2) {
                            file_output& tf = file_outs.alloc(names[i].c_str());
                            file            = &tf;
                            tf.ed           = this;
                            observation_outputs[index] = file_outs.get_id(tf);
                            auto& o                    = sim.observers.alloc(
                              names[i].c_str(), file_output_callback, &tf);
                            sim.observe(*mdl, o);
                        } else {
                            file = file_outs.try_to_get(
                              std::get<file_output_id>(out));
                            irt_assert(file);
                        }

                        ImGui::InputText(""name##file"",
                                         file->name.begin(),
                                         file->name.capacity());
                    } else if (choose == 3) {
                        if (old_choose == 1 || old_choose == 2) {
                            sim.observers.free(mdl->obs_id);
                            observation_outputs_free(index);
                        }

                        file_discrete_output* file;
                        if (old_choose != 3) {
                            file_discrete_output& tf =
                              file_discrete_outs.alloc(names[i].c_str());
                            file  = &tf;
                            tf.ed = this;
                            observation_outputs[index] =
                              file_discrete_outs.get_id(tf);
                            auto& o =
                              sim.observers.alloc(names[i].c_str(),
                                                  file_discrete_output_callback,
                                                  &tf);
                            sim.observe(*mdl, o);
                        } else {
                            file = file_discrete_outs.try_to_get(
                              std::get<file_discrete_output_id>(out));
                            irt_assert(file);
                        }

                        ImGui::InputText(""name##filedt"",
                                         file->name.begin(),
                                         file->name.capacity());
                        ImGui::InputReal(""dt##filedt"",
                                         &file->time_step,
                                         to_real(0.001),
                                         to_real(1.0),
                                         ""%.8f"");
                    } else if (old_choose != choose) {
                        sim.observers.free(mdl->obs_id);
                        observation_outputs_free(index);
                    }

                    dispatch(*mdl, [this]<typename Dynamics>(Dynamics& dyn) {
                        ImGui::Spacing();
                        show_dynamics_inputs(this->srcs, dyn);
                    });

                    ImGui::TreePop();
                }
            }
        }

        ImGui::EndTable();
    }
}

bool editor::show_window() noexcept
{
    ImGuiWindowFlags windows_flags = 0;
    windows_flags |= ImGuiWindowFlags_MenuBar;

    ImGui::SetNextWindowPos(ImVec2(500, 50), ImGuiCond_FirstUseEver);
    ImGui::SetNextWindowSize(ImVec2(800, 700), ImGuiCond_Once);
    if (!ImGui::Begin(name.c_str(), &show, windows_flags)) {
        ImGui::End();
        return true;
    }

    if (ImGui::BeginMenuBar()) {
        if (ImGui::BeginMenu(""File"")) {
            if (ImGui::MenuItem(""Open""))
                show_load_file_dialog = true;

            if (!path.empty() && ImGui::MenuItem(""Save"")) {
                log_w.log(3,
                          ""Write into file %s\\n"",
                          (const char*)path.u8string().c_str());
                if (auto os = std::ofstream(path); os.is_open()) {
                    writer w(os);
                    auto   ret = w(sim, srcs);
                    if (is_success(ret))
                        log_w.log(5, ""success\\n"");
                    else
                        log_w.log(4, ""error writing\\n"");
                }
            }

            if (ImGui::MenuItem(""Save as...""))
                show_save_file_dialog = true;

            if (ImGui::MenuItem(""Close"")) {
                ImGui::EndMenu();
                ImGui::EndMenuBar();
                ImGui::End();
                return false;
            }

            ImGui::EndMenu();
        }

        if (ImGui::BeginMenu(""Edition"")) {
            ImGui::MenuItem(""Show minimap"", nullptr, &show_minimap);
            ImGui::MenuItem(""Show parameter in models"",
                            nullptr,
                            &settings.show_dynamics_inputs_in_editor);
            ImGui::Separator();
            if (ImGui::MenuItem(""Clear""))
                clear();
            ImGui::Separator();
            if (ImGui::MenuItem(""Grid Reorder""))
                compute_grid_layout();
            if (ImGui::MenuItem(""Automatic Layout""))
                compute_automatic_layout();
            ImGui::Separator();
            if (ImGui::MenuItem(""Settings""))
                show_settings = true;

            ImGui::EndMenu();
        }

        auto empty_fun = [this](irt::model_id /*id*/) {};

        if (ImGui::BeginMenu(""Examples"")) {
            if (ImGui::MenuItem(""Insert example AQSS lotka_volterra""))
                if (auto ret = add_lotka_volterra(); is_bad(ret))
                    log_w.log(3,
                              ""Fail to initialize a Lotka Volterra ""
                              ""model (%s)\\n"",
                              status_string(ret));
            if (ImGui::MenuItem(""Insert Izhikevitch model""))
                if (auto ret = add_izhikevitch(); is_bad(ret))
                    log_w.log(3,
                              ""Fail to initialize an Izhikevitch ""
                              ""model (%s)\\n"",
                              status_string(ret));

            if (ImGui::MenuItem(""Insert example QSS1 lotka_volterra""))
                if (auto ret = example_qss_lotka_volterra<1>(sim, empty_fun);
                    is_bad(ret))
                    log_w.log(3,
                              ""Fail to initialize ""
                              ""example_qss_lotka_volterra<1>: %s\\n"",
                              status_string(ret));
            if (ImGui::MenuItem(""Insert example QSS1 negative_lif""))
                if (auto ret = example_qss_negative_lif<1>(sim, empty_fun);
                    is_bad(ret))
                    log_w.log(3,
                              ""Fail to initialize ""
                              ""example_qss_negative_lif<1>: %s\\n"",
                              status_string(ret));
            if (ImGui::MenuItem(""Insert example QSS1 lif""))
                if (auto ret = example_qss_lif<1>(sim, empty_fun); is_bad(ret))
                    log_w.log(3,
                              ""Fail to initialize example_qss_lif<1>: %s\\n"",
                              status_string(ret));
            if (ImGui::MenuItem(""Insert example QSS1 van_der_pol""))
                if (auto ret = example_qss_van_der_pol<1>(sim, empty_fun);
                    is_bad(ret))
                    log_w.log(
                      3,
                      ""Fail to initialize example_qss_van_der_pol<1>: %s\\n"",
                      status_string(ret));
            if (ImGui::MenuItem(""Insert example QSS1 izhikevich""))
                if (auto ret = example_qss_izhikevich<1>(sim, empty_fun);
                    is_bad(ret))
                    log_w.log(
                      3,
                      ""Fail to initialize example_qss_izhikevich<1>: %s\\n"",
                      status_string(ret));
            if (ImGui::MenuItem(""Insert example QSS1 seir_nonlinear""))
                if (auto ret = example_qss_seir_nonlinear<1>(sim, empty_fun);
                    is_bad(ret))
                    log_w.log(
                      3,
                      ""Fail to initialize example_qss_seir_nonlinear<1>: %s\\n"",
                      status_string(ret));
            if (ImGui::MenuItem(""Insert example QSS2 lotka_volterra""))
                if (auto ret = example_qss_lotka_volterra<2>(sim, empty_fun);
                    is_bad(ret))
                    log_w.log(3,
                              ""Fail to initialize ""
                              ""example_qss_lotka_volterra<2>: %s\\n"",
                              status_string(ret));
            if (ImGui::MenuItem(""Insert example QSS2 negative_lif""))
                if (auto ret = example_qss_negative_lif<2>(sim, empty_fun);
                    is_bad(ret))
                    log_w.log(3,
                              ""Fail to initialize ""
                              ""example_qss_negative_lif<2>: %s\\n"",
                              status_string(ret));
            if (ImGui::MenuItem(""Insert example QSS2 lif""))
                if (auto ret = example_qss_lif<2>(sim, empty_fun); is_bad(ret))
                    log_w.log(3,
                              ""Fail to initialize example_qss_lif<2>: %s\\n"",
                              status_string(ret));
            if (ImGui::MenuItem(""Insert example QSS2 van_der_pol""))
                if (auto ret = example_qss_van_der_pol<2>(sim, empty_fun);
                    is_bad(ret))
                    log_w.log(
                      3,
                      ""Fail to initialize example_qss_van_der_pol<2>: %s\\n"",
                      status_string(ret));
            if (ImGui::MenuItem(""Insert example QSS2 izhikevich""))
                if (auto ret = example_qss_izhikevich<2>(sim, empty_fun);
                    is_bad(ret))
                    log_w.log(
                      3,
                      ""Fail to initialize example_qss_izhikevich<2>: %s\\n"",
                      status_string(ret));
            if (ImGui::MenuItem(""Insert example QSS2 seir_nonlinear""))
                if (auto ret = example_qss_seir_nonlinear<2>(sim, empty_fun);
                    is_bad(ret))
                    log_w.log(
                      3,
                      ""Fail to initialize example_qss_seir_nonlinear<2>: %s\\n"",
                      status_string(ret));

            if (ImGui::MenuItem(""Insert example QSS3 lotka_volterra""))
                if (auto ret = example_qss_lotka_volterra<3>(sim, empty_fun);
                    is_bad(ret))
                    log_w.log(3,
                              ""Fail to initialize ""
                              ""example_qss_lotka_volterra<3>: %s\\n"",
                              status_string(ret));
            if (ImGui::MenuItem(""Insert example QSS3 negative_lif""))
                if (auto ret = example_qss_negative_lif<3>(sim, empty_fun);
                    is_bad(ret))
                    log_w.log(3,
                              ""Fail to initialize ""
                              ""example_qss_negative_lif<3>: %s\\n"",
                              status_string(ret));
            if (ImGui::MenuItem(""Insert example QSS3 lif""))
                if (auto ret = example_qss_lif<3>(sim, empty_fun); is_bad(ret))
                    log_w.log(3,
                              ""Fail to initialize example_qss_lif<3>: %s\\n"",
                              status_string(ret));
            if (ImGui::MenuItem(""Insert example QSS3 van_der_pol""))
                if (auto ret = example_qss_van_der_pol<3>(sim, empty_fun);
                    is_bad(ret))
                    log_w.log(
                      3,
                      ""Fail to initialize example_qss_van_der_pol<3>: %s\\n"",
                      status_string(ret));
            if (ImGui::MenuItem(""Insert example QSS3 izhikevich""))
                if (auto ret = example_qss_izhikevich<3>(sim, empty_fun);
                    is_bad(ret))
                    log_w.log(
                      3,
                      ""Fail to initialize example_qss_izhikevich<3>: %s\\n"",
                      status_string(ret));
            if (ImGui::MenuItem(""Insert example QSS3 seir_nonlinear""))
                if (auto ret = example_qss_seir_nonlinear<3>(sim, empty_fun);
                    is_bad(ret))
                    log_w.log(
                      3,
                      ""Fail to initialize example_qss_seir_nonlinear<3>: %s\\n"",
                      status_string(ret));

            ImGui::EndMenu();
        }

        ImGui::EndMenuBar();
    }

    if (show_select_directory_dialog) {
        ImGui::OpenPopup(""Select directory"");
        if (select_directory_dialog(observation_directory)) {
            show_select_directory_dialog = false;

            log_w.log(
              5, ""Output directory: %s"", (const char*)path.u8string().c_str());
        }
    }

    if (show_load_file_dialog) {
        const char*    title     = ""Select file path to load"";
        const char8_t* filters[] = { u8"".irt"", nullptr };

        ImGui::OpenPopup(title);
        if (load_file_dialog(path, title, filters)) {
            show_load_file_dialog = false;
            log_w.log(
              5, ""Load file from %s: "", (const char*)path.u8string().c_str());
            if (auto is = std::ifstream(path); is.is_open()) {
                reader r(is);
                auto   ret = r(sim, srcs, [&r, this](model_id id) {
                    const auto index = get_index(id);
                    const auto pos   = r.get_position(index);

                    ImNodes::SetNodeEditorSpacePos(index, ImVec2(pos.x, pos.y));
                });

                if (is_success(ret))
                    log_w.log(5, ""success\\n"");
                else
                    log_w.log(4, ""fail\\n"");
            }
        }
    }

    if (show_save_file_dialog) {
        if (sim.models.size()) {
            const char*    title     = ""Select file path to save"";
            const char8_t* filters[] = { u8"".irt"", nullptr };

            ImGui::OpenPopup(title);
            if (save_file_dialog(path, title, filters)) {
                show_save_file_dialog = false;
                log_w.log(
                  5, ""Save file to %s\\n"", (const char*)path.u8string().c_str());

                log_w.log(3,
                          ""Write into file %s\\n"",
                          (const char*)path.u8string().c_str());
                if (auto os = std::ofstream(path); os.is_open()) {
                    writer w(os);

                    auto ret =
                      w(sim, srcs, [](model_id mdl_id, float& x, float& y) {
                          const auto index = irt::get_index(mdl_id);
                          const auto pos   = ImNodes::GetNodeEditorSpacePos(
                            static_cast<int>(index));
                          x = pos.x;
                          y = pos.y;
                      });

                    if (is_success(ret))
                        log_w.log(5, ""success\\n"");
                    else
                        log_w.log(4, ""error writing\\n"");
                }
            }
        }
    }

    constexpr ImGuiTabBarFlags tab_bar_flags = ImGuiTabBarFlags_None;
    if (ImGui::BeginTabBar(""editor bar"", tab_bar_flags)) {
        if (ImGui::BeginTabItem(""model"")) {
            show_editor();
            ImGui::EndTabItem();
        }
        if (ImGui::BeginTabItem(""sources"")) {
            show_sources();
            ImGui::EndTabItem();
        }
        ImGui::EndTabBar();
    }

    ImGui::End();

    return true;
}

} // namespace irt
",16153,True,2777.4248149126083,median
"= v1.SecurityContextConstraints
{product-author}
{product-version}
:data-uri:
:icons:
:toc: macro
:toc-title:
:toclevels: 2

toc::[]

== Description
[%hardbreaks]
SecurityContextConstraints governs the ability to make requests that affect the SecurityContext that will be applied to a container. For historical reasons SCC was exposed under the core Kubernetes API group. That exposure is deprecated and will be removed in a future release - users should instead use the security.openshift.io group to manage SecurityContextConstraints.

== Object Schema
Expand or mouse-over a field for more information about it.

++++
<pre>
<div style=""margin-left:13px;""><span title=""(boolean) AllowHostDirVolumePlugin determines if the policy allow containers to use the HostDir volume plugin"">allowHostDirVolumePlugin</span>:
</div><div style=""margin-left:13px;""><span title=""(boolean) AllowHostIPC determines if the policy allows host ipc in the containers."">allowHostIPC</span>:
</div><div style=""margin-left:13px;""><span title=""(boolean) AllowHostNetwork determines if the policy allows the use of HostNetwork in the pod spec."">allowHostNetwork</span>:
</div><div style=""margin-left:13px;""><span title=""(boolean) AllowHostPID determines if the policy allows host pid in the containers."">allowHostPID</span>:
</div><div style=""margin-left:13px;""><span title=""(boolean) AllowHostPorts determines if the policy allows host ports in the containers."">allowHostPorts</span>:
</div><div style=""margin-left:13px;""><span title=""(boolean) AllowPrivilegeEscalation determines if a pod can request to allow privilege escalation. If unspecified, defaults to true."">allowPrivilegeEscalation</span>:
</div><div style=""margin-left:13px;""><span title=""(boolean) AllowPrivilegedContainer determines if a container can request to be run as privileged."">allowPrivilegedContainer</span>:
</div><details><summary><span title=""(array) AllowedCapabilities is a list of capabilities that can be requested to add to the container. Capabilities in this field maybe added at the pod author&#39;s discretion. You must not list a capability in both AllowedCapabilities and RequiredDropCapabilities. To allow all capabilities you may use &#39;*&#39;."">allowedCapabilities</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details><details><summary><span title=""(array) AllowedFlexVolumes is a whitelist of allowed Flexvolumes.  Empty or nil indicates that all Flexvolumes may be used.  This parameter is effective only when the usage of the Flexvolumes is allowed in the &#34;Volumes&#34; field."">allowedFlexVolumes</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string) Driver is the name of the Flexvolume driver."">driver</span>:
</div></details><details><summary><span title=""(array) AllowedUnsafeSysctls is a list of explicitly allowed unsafe sysctls, defaults to none. Each entry is either a plain sysctl name or ends in &#34;*&#34; in which case it is considered as a prefix of allowed sysctls. Single * means all unsafe sysctls are allowed. Kubelet has to whitelist all allowed unsafe sysctls explicitly to avoid rejection.

Examples: e.g. &#34;foo/*&#34; allows &#34;foo/bar&#34;, &#34;foo/baz&#34;, etc. e.g. &#34;foo.*&#34; allows &#34;foo.bar&#34;, &#34;foo.baz&#34;, etc."">allowedUnsafeSysctls</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;""><span title=""(string) APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources"">apiVersion</span>:
</div><details><summary><span title=""(array) DefaultAddCapabilities is the default set of capabilities that will be added to the container unless the pod spec specifically drops the capability.  You may not list a capabiility in both DefaultAddCapabilities and RequiredDropCapabilities."">defaultAddCapabilities</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;""><span title=""(boolean) DefaultAllowPrivilegeEscalation controls the default setting for whether a process can gain more privileges than its parent process."">defaultAllowPrivilegeEscalation</span>:
</div><details><summary><span title=""(array) ForbiddenSysctls is a list of explicitly forbidden sysctls, defaults to none. Each entry is either a plain sysctl name or ends in &#34;*&#34; in which case it is considered as a prefix of forbidden sysctls. Single * means all sysctls are forbidden.

Examples: e.g. &#34;foo/*&#34; forbids &#34;foo/bar&#34;, &#34;foo/baz&#34;, etc. e.g. &#34;foo.*&#34; forbids &#34;foo.bar&#34;, &#34;foo.baz&#34;, etc."">forbiddenSysctls</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details><details><summary><span title=""(v1.FSGroupStrategyOptions) FSGroup is the strategy that will dictate what fs group is used by the SecurityContext."">fsGroup</span>:
</summary><details><summary>  <span title=""(array) Ranges are the allowed ranges of fs groups.  If you would like to force a single fs group then supply a single range with the same start and end."">ranges</span>:
</summary><div style=""margin-left:13px;"">  - <span title=""(integer) Max is the end of the range, inclusive."">max</span>:
</div><div style=""margin-left:13px;"">    <span title=""(integer) Min is the start of the range, inclusive."">min</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) Type is the strategy that will dictate what FSGroup is used in the SecurityContext."">type</span>:
</div></details><details><summary><span title=""(array) The groups that have permission to use this security context constraints"">groups</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;""><span title=""(string) Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><details open><summary><span title=""(v1.ObjectMeta) Standard object&#39;s metadata. More info: http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#metadata"">metadata</span>:
</summary><details><summary>  <span title=""(object) Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations"">annotations</span>:
</summary><div style=""margin-left:13px;"">    <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) The name of the cluster which the object belongs to. This is used to distinguish resources with same name and namespace in different clusters. This field is not set anywhere right now and apiserver is going to ignore it if set in create or update request."">clusterName</span>:
</div><div style=""margin-left:13px;"">  <span title=""(v1.Time) CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.

Populated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata"">creationTimestamp</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only."">deletionGracePeriodSeconds</span>:
</div><div style=""margin-left:13px;"">  <span title=""(v1.Time) DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.

Populated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata"">deletionTimestamp</span>:
</div><details><summary>  <span title=""(array) Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed."">finalizers</span>:
</summary><div style=""margin-left:13px;"">  - <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.

If this field is specified and the generated name exists, the server will NOT return a 409 - instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, and the client should retry (optionally after the time indicated in the Retry-After header).

Applied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#idempotency"">generateName</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) A sequence number representing a specific generation of the desired state. Populated by the system. Read-only."">generation</span>:
</div><details><summary>  <span title=""(v1.Initializers) An initializer is a controller which enforces some system invariant at object creation time. This field is a list of initializers that have not yet acted on this object. If nil or empty, this object has been completely initialized. Otherwise, the object is considered uninitialized and is hidden (in list/watch and get calls) from clients that haven&#39;t explicitly asked to observe uninitialized objects.

When an object is created, the system will populate this list with the current set of initializers. Only privileged users may set or modify this list. Once it is empty, it may not be modified further by any user."">initializers</span>:
</summary><details><summary>    <span title=""(array) Pending is a list of initializers that must execute in order before this object is visible. When the last pending initializer is removed, and no failing result is set, the initializers struct will be set to nil and the object is considered as initialized and visible to all clients."">pending</span>:
</summary><div style=""margin-left:13px;"">    - <span title=""(string) name of the process that is responsible for initializing this object."">name</span>:
</div></details><details><summary>    <span title=""(v1.Status) If result is set with the Failure field, the object will be persisted to storage and then deleted, ensuring that other clients can observe the deletion."">result</span>:
</summary><div style=""margin-left:13px;"">      <span title=""(string) APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources"">apiVersion</span>:
</div><div style=""margin-left:13px;"">      <span title=""(integer) Suggested HTTP return code for this status, 0 if not set."">code</span>:
</div><details><summary>      <span title=""(v1.StatusDetails) Extended data associated with the reason.  Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type."">details</span>:
</summary><details><summary>        <span title=""(array) The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes."">causes</span>:
</summary><div style=""margin-left:13px;"">        - <span title=""(string) The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed.  Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.

Examples:
  &#34;name&#34; - the field &#34;name&#34; on the current resource
  &#34;items[0].name&#34; - the field &#34;name&#34; on the first array entry in &#34;items&#34;"">field</span>:
</div><div style=""margin-left:13px;"">          <span title=""(string) A human-readable description of the cause of the error.  This field may be presented as-is to a reader."">message</span>:
</div><div style=""margin-left:13px;"">          <span title=""(string) A machine-readable description of the cause of the error. If this value is empty there is no information available."">reason</span>:
</div></details><div style=""margin-left:13px;"">        <span title=""(string) The group attribute of the resource associated with the status StatusReason."">group</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described)."">name</span>:
</div><div style=""margin-left:13px;"">        <span title=""(integer) If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action."">retryAfterSeconds</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) UID of the resource. (when there is a single resource which can be described). More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><div style=""margin-left:13px;"">      <span title=""(string) Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">      <span title=""(string) A human-readable description of the status of this operation."">message</span>:
</div><details><summary>      <span title=""(v1.ListMeta) Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">metadata</span>:
</summary><div style=""margin-left:13px;"">        <span title=""(string) continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response."">continue</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) String that identifies the server&#39;s internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency"">resourceVersion</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) selfLink is a URL representing this object. Populated by the system. Read-only."">selfLink</span>:
</div></details><div style=""margin-left:13px;"">      <span title=""(string) A machine-readable description of why this operation is in the &#34;Failure&#34; status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it."">reason</span>:
</div><div style=""margin-left:13px;"">      <span title=""(string) Status of the operation. One of: &#34;Success&#34; or &#34;Failure&#34;. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#spec-and-status"">status</span>:
</div></details></details><details><summary>  <span title=""(object) Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels"">labels</span>:
</summary><div style=""margin-left:13px;"">    <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names"">name</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Namespace defines the space within each name must be unique. An empty namespace is equivalent to the &#34;default&#34; namespace, but &#34;default&#34; is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.

Must be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces"">namespace</span>:
</div><details><summary>  <span title=""(array) List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller."">ownerReferences</span>:
</summary><div style=""margin-left:13px;"">  - <span title=""(string) API version of the referent."">apiVersion</span>:
</div><div style=""margin-left:13px;"">    <span title=""(boolean) If true, AND if the owner has the &#34;foregroundDeletion&#34; finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. Defaults to false. To set this field, a user needs &#34;delete&#34; permission of the owner, otherwise 422 (Unprocessable Entity) will be returned."">blockOwnerDeletion</span>:
</div><div style=""margin-left:13px;"">    <span title=""(boolean) If true, this reference points to the managing controller."">controller</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names"">name</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.

Populated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency"">resourceVersion</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) SelfLink is a URL representing this object. Populated by the system. Read-only."">selfLink</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.

Populated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><div style=""margin-left:13px;""><span title=""(integer) Priority influences the sort order of SCCs when evaluating which SCCs to try first for a given pod request based on access in the Users and Groups fields.  The higher the int, the higher priority. An unset value is considered a 0 priority. If scores for multiple SCCs are equal they will be sorted from most restrictive to least restrictive. If both priorities and restrictions are equal the SCCs will be sorted by name."">priority</span>:
</div><div style=""margin-left:13px;""><span title=""(boolean) ReadOnlyRootFilesystem when set to true will force containers to run with a read only root file system.  If the container specifically requests to run with a non-read only root file system the SCC should deny the pod. If set to false the container may run with a read only root file system if it wishes but it will not be forced to."">readOnlyRootFilesystem</span>:
</div><details><summary><span title=""(array) RequiredDropCapabilities are the capabilities that will be dropped from the container.  These are required to be dropped and cannot be added."">requiredDropCapabilities</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details><details><summary><span title=""(v1.RunAsUserStrategyOptions) RunAsUser is the strategy that will dictate what RunAsUser is used in the SecurityContext."">runAsUser</span>:
</summary><div style=""margin-left:13px;"">  <span title=""(string) Type is the strategy that will dictate what RunAsUser is used in the SecurityContext."">type</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) UID is the user id that containers must run as.  Required for the MustRunAs strategy if not using namespace/service account allocated uids."">uid</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) UIDRangeMax defines the max value for a strategy that allocates by range."">uidRangeMax</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) UIDRangeMin defines the min value for a strategy that allocates by range."">uidRangeMin</span>:
</div></details><details><summary><span title=""(v1.SELinuxContextStrategyOptions) SELinuxContext is the strategy that will dictate what labels will be set in the SecurityContext."">seLinuxContext</span>:
</summary><details><summary>  <span title=""(v1.SELinuxOptions) seLinuxOptions required to run as; required for MustRunAs"">seLinuxOptions</span>:
</summary><div style=""margin-left:13px;"">    <span title=""(string) Level is SELinux level label that applies to the container."">level</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) Role is a SELinux role label that applies to the container."">role</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) Type is a SELinux type label that applies to the container."">type</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) User is a SELinux user label that applies to the container."">user</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) Type is the strategy that will dictate what SELinux context is used in the SecurityContext."">type</span>:
</div></details><details><summary><span title=""(array) SeccompProfiles lists the allowed profiles that may be set for the pod or container&#39;s seccomp annotations.  An unset (nil) or empty value means that no profiles may be specifid by the pod or container.	The wildcard &#39;*&#39; may be used to allow all profiles.  When used to generate a value for a pod the first non-wildcard profile will be used as the default."">seccompProfiles</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details><details><summary><span title=""(v1.SupplementalGroupsStrategyOptions) SupplementalGroups is the strategy that will dictate what supplemental groups are used by the SecurityContext."">supplementalGroups</span>:
</summary><details><summary>  <span title=""(array) Ranges are the allowed ranges of supplemental groups.  If you would like to force a single supplemental group then supply a single range with the same start and end."">ranges</span>:
</summary><div style=""margin-left:13px;"">  - <span title=""(integer) Max is the end of the range, inclusive."">max</span>:
</div><div style=""margin-left:13px;"">    <span title=""(integer) Min is the start of the range, inclusive."">min</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) Type is the strategy that will dictate what supplemental groups is used in the SecurityContext."">type</span>:
</div></details><details><summary><span title=""(array) The users who have permissions to use this security context constraints"">users</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details><details><summary><span title=""(array) Volumes is a white list of allowed volume plugins.  FSType corresponds directly with the field names of a VolumeSource (azureFile, configMap, emptyDir).  To allow all volumes you may use &#34;*&#34;. To allow no volumes, set to [&#34;none&#34;]."">volumes</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details>
</pre>
++++

== Operations

[[Post-apis-security.openshift.io-v1-securitycontextconstraints]]
=== Create a SecurityContextConstraints
Create SecurityContextConstraints

==== HTTP request
----
POST /apis/security.openshift.io/v1/securitycontextconstraints HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""SecurityContextConstraints"",
  ""apiVersion"": ""security.openshift.io/v1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X POST \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/apis/security.openshift.io/v1/securitycontextconstraints <<'EOF'
{
  ""kind"": ""SecurityContextConstraints"",
  ""apiVersion"": ""security.openshift.io/v1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.SecurityContextConstraints
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.SecurityContextConstraints
|201 Created|v1.SecurityContextConstraints
|202 Accepted|v1.SecurityContextConstraints
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Get-apis-security.openshift.io-v1-securitycontextconstraints-name]]
=== Get a SecurityContextConstraints
Read the specified SecurityContextConstraints

==== HTTP request
----
GET /apis/security.openshift.io/v1/securitycontextconstraints/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/security.openshift.io/v1/securitycontextconstraints/$NAME
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the SecurityContextConstraints
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|exact|Should the export be exact.  Exact export maintains cluster-specific fields like 'Namespace'.
|export|Should this value be exported.  Export strips fields that a user can not specify.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.SecurityContextConstraints
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Get-apis-security.openshift.io-v1-securitycontextconstraints]]
=== Get all SecurityContextConstraints
List or watch objects of kind SecurityContextConstraints

==== HTTP request
----
GET /apis/security.openshift.io/v1/securitycontextconstraints HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/security.openshift.io/v1/securitycontextconstraints
----

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.SecurityContextConstraintsList
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-apis-security.openshift.io-v1-watch-securitycontextconstraints-name]]
=== Watch a SecurityContextConstraints
Watch changes to an object of kind SecurityContextConstraints

==== HTTP request
----
GET /apis/security.openshift.io/v1/watch/securitycontextconstraints/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/security.openshift.io/v1/watch/securitycontextconstraints/$NAME
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the SecurityContextConstraints
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|pretty|If 'true', then the output is pretty printed.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.WatchEvent
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-apis-security.openshift.io-v1-watch-securitycontextconstraints]]
=== Watch all SecurityContextConstraints
Watch individual changes to a list of SecurityContextConstraints

==== HTTP request
----
GET /apis/security.openshift.io/v1/watch/securitycontextconstraints HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/security.openshift.io/v1/watch/securitycontextconstraints
----

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|pretty|If 'true', then the output is pretty printed.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.WatchEvent
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Put-apis-security.openshift.io-v1-securitycontextconstraints-name]]
=== Update a SecurityContextConstraints
Replace the specified SecurityContextConstraints

==== HTTP request
----
PUT /apis/security.openshift.io/v1/securitycontextconstraints/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""SecurityContextConstraints"",
  ""apiVersion"": ""security.openshift.io/v1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X PUT \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/apis/security.openshift.io/v1/securitycontextconstraints/$NAME <<'EOF'
{
  ""kind"": ""SecurityContextConstraints"",
  ""apiVersion"": ""security.openshift.io/v1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.SecurityContextConstraints
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the SecurityContextConstraints
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.SecurityContextConstraints
|201 Created|v1.SecurityContextConstraints
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Patch-apis-security.openshift.io-v1-securitycontextconstraints-name]]
=== Patch a SecurityContextConstraints
Partially update the specified SecurityContextConstraints

==== HTTP request
----
PATCH /apis/security.openshift.io/v1/securitycontextconstraints/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json-patch+json'

{
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X PATCH \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json-patch+json' \\
    https://$ENDPOINT/apis/security.openshift.io/v1/securitycontextconstraints/$NAME <<'EOF'
{
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.Patch
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the SecurityContextConstraints
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.SecurityContextConstraints
|401 Unauthorized|
|===

==== Consumes

* application/json-patch+json
* application/merge-patch+json
* application/strategic-merge-patch+json

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Delete-apis-security.openshift.io-v1-securitycontextconstraints-name]]
=== Delete a SecurityContextConstraints
Delete SecurityContextConstraints

==== HTTP request
----
DELETE /apis/security.openshift.io/v1/securitycontextconstraints/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X DELETE \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/apis/security.openshift.io/v1/securitycontextconstraints/$NAME <<'EOF'
{
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.DeleteOptions
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the SecurityContextConstraints
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|gracePeriodSeconds|The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
|orphanDependents|Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the ""orphan"" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
|propagationPolicy|Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.Status
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Delete-apis-security.openshift.io-v1-securitycontextconstraints]]
=== Delete all SecurityContextConstraints
Delete collection of SecurityContextConstraints

==== HTTP request
----
DELETE /apis/security.openshift.io/v1/securitycontextconstraints HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -X DELETE \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/security.openshift.io/v1/securitycontextconstraints
----

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.Status
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf



",12334,False,2106.6587662619454,median
"/*
 * Copyright 2011-2013 Blender Foundation
 *
 * 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.
 */

#ifdef WITH_OPENCL

#  include ""device/opencl/opencl.h""

#  include ""kernel/kernel_types.h""
#  include ""kernel/split/kernel_split_data_types.h""

#  include ""util/util_algorithm.h""
#  include ""util/util_debug.h""
#  include ""util/util_foreach.h""
#  include ""util/util_logging.h""
#  include ""util/util_md5.h""
#  include ""util/util_path.h""
#  include ""util/util_time.h""

CCL_NAMESPACE_BEGIN

struct texture_slot_t {
  texture_slot_t(const string &name, int slot) : name(name), slot(slot)
  {
  }
  string name;
  int slot;
};

static const string NON_SPLIT_KERNELS =
    ""denoising ""
    ""base ""
    ""background ""
    ""displace "";

static const string SPLIT_BUNDLE_KERNELS =
    ""data_init ""
    ""path_init ""
    ""state_buffer_size ""
    ""scene_intersect ""
    ""queue_enqueue ""
    ""shader_setup ""
    ""shader_sort ""
    ""enqueue_inactive ""
    ""next_iteration_setup ""
    ""indirect_subsurface ""
    ""buffer_update"";

const string OpenCLDevice::get_opencl_program_name(const string &kernel_name)
{
  if (NON_SPLIT_KERNELS.find(kernel_name) != std::string::npos) {
    return kernel_name;
  }
  else if (SPLIT_BUNDLE_KERNELS.find(kernel_name) != std::string::npos) {
    return ""split_bundle"";
  }
  else {
    return ""split_"" + kernel_name;
  }
}

const string OpenCLDevice::get_opencl_program_filename(const string &kernel_name)
{
  if (kernel_name == ""denoising"") {
    return ""filter.cl"";
  }
  else if (SPLIT_BUNDLE_KERNELS.find(kernel_name) != std::string::npos) {
    return ""kernel_split_bundle.cl"";
  }
  else {
    return ""kernel_"" + kernel_name + "".cl"";
  }
}

/* Enable features that we always want to compile to reduce recompilation events */
void OpenCLDevice::enable_default_features(DeviceRequestedFeatures &features)
{
  features.use_transparent = true;
  features.use_shadow_tricks = true;
  features.use_principled = true;
  features.use_denoising = true;

  if (!background) {
    features.max_nodes_group = NODE_GROUP_LEVEL_MAX;
    features.nodes_features = NODE_FEATURE_ALL;
    features.use_hair = true;
    features.use_subsurface = true;
    features.use_camera_motion = false;
    features.use_object_motion = false;
  }
}

string OpenCLDevice::get_build_options(const DeviceRequestedFeatures &requested_features,
                                       const string &opencl_program_name,
                                       bool preview_kernel)
{
  /* first check for non-split kernel programs */
  if (opencl_program_name == ""base"" || opencl_program_name == ""denoising"") {
    return """";
  }
  else if (opencl_program_name == ""bake"") {
    /* Note: get_build_options for bake is only requested when baking is enabled.
     * displace and background are always requested.
     * `__SPLIT_KERNEL__` must not be present in the compile directives for bake */
    DeviceRequestedFeatures features(requested_features);
    enable_default_features(features);
    features.use_denoising = false;
    features.use_object_motion = false;
    features.use_camera_motion = false;
    features.use_hair = true;
    features.use_subsurface = true;
    features.max_nodes_group = NODE_GROUP_LEVEL_MAX;
    features.nodes_features = NODE_FEATURE_ALL;
    features.use_integrator_branched = false;
    return features.get_build_options();
  }
  else if (opencl_program_name == ""displace"") {
    /* As displacement does not use any nodes from the Shading group (eg BSDF).
     * We disable all features that are related to shading. */
    DeviceRequestedFeatures features(requested_features);
    enable_default_features(features);
    features.use_denoising = false;
    features.use_object_motion = false;
    features.use_camera_motion = false;
    features.use_baking = false;
    features.use_transparent = false;
    features.use_shadow_tricks = false;
    features.use_subsurface = false;
    features.use_volume = false;
    features.nodes_features &= ~NODE_FEATURE_VOLUME;
    features.use_denoising = false;
    features.use_principled = false;
    features.use_integrator_branched = false;
    return features.get_build_options();
  }
  else if (opencl_program_name == ""background"") {
    /* Background uses Background shading
     * It is save to disable shadow features, subsurface and volumetric. */
    DeviceRequestedFeatures features(requested_features);
    enable_default_features(features);
    features.use_baking = false;
    features.use_object_motion = false;
    features.use_camera_motion = false;
    features.use_transparent = false;
    features.use_shadow_tricks = false;
    features.use_denoising = false;
    /* NOTE: currently possible to use surface nodes like `Hair Info`, `Bump` node.
     * Perhaps we should remove them in UI as it does not make any sense when
     * rendering background. */
    features.nodes_features &= ~NODE_FEATURE_VOLUME;
    features.use_subsurface = false;
    features.use_volume = false;
    features.use_shader_raytrace = false;
    features.use_patch_evaluation = false;
    features.use_integrator_branched = false;
    return features.get_build_options();
  }

  string build_options = ""-D__SPLIT_KERNEL__ "";
  /* Set compute device build option. */
  cl_device_type device_type;
  OpenCLInfo::get_device_type(this->cdDevice, &device_type, &this->ciErr);
  assert(this->ciErr == CL_SUCCESS);
  if (device_type == CL_DEVICE_TYPE_GPU) {
    build_options += ""-D__COMPUTE_DEVICE_GPU__ "";
  }

  DeviceRequestedFeatures nofeatures;
  enable_default_features(nofeatures);

  /* Add program specific optimized compile directives */
  if (preview_kernel) {
    DeviceRequestedFeatures preview_features;
    preview_features.use_hair = true;
    build_options += ""-D__KERNEL_AO_PREVIEW__ "";
    build_options += preview_features.get_build_options();
  }
  else if (opencl_program_name == ""split_do_volume"" && !requested_features.use_volume) {
    build_options += nofeatures.get_build_options();
  }
  else {
    DeviceRequestedFeatures features(requested_features);
    enable_default_features(features);

    /* Always turn off baking at this point. Baking is only useful when building the bake kernel.
     * this also makes sure that the kernels that are build during baking can be reused
     * when not doing any baking. */
    features.use_baking = false;

    /* Do not vary on shaders when program doesn't do any shading.
     * We have bundled them in a single program. */
    if (opencl_program_name == ""split_bundle"") {
      features.max_nodes_group = 0;
      features.nodes_features = 0;
      features.use_shader_raytrace = false;
    }

    /* No specific settings, just add the regular ones */
    build_options += features.get_build_options();
  }

  return build_options;
}

OpenCLDevice::OpenCLSplitPrograms::OpenCLSplitPrograms(OpenCLDevice *device_)
{
  device = device_;
}

OpenCLDevice::OpenCLSplitPrograms::~OpenCLSplitPrograms()
{
  program_split.release();
  program_lamp_emission.release();
  program_do_volume.release();
  program_indirect_background.release();
  program_shader_eval.release();
  program_holdout_emission_blurring_pathtermination_ao.release();
  program_subsurface_scatter.release();
  program_direct_lighting.release();
  program_shadow_blocked_ao.release();
  program_shadow_blocked_dl.release();
}

void OpenCLDevice::OpenCLSplitPrograms::load_kernels(
    vector<OpenCLProgram *> &programs,
    const DeviceRequestedFeatures &requested_features,
    bool is_preview)
{
  if (!requested_features.use_baking) {
#  define ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(kernel_name) \\
    program_split.add_kernel(ustring(""path_trace_"" #kernel_name));
#  define ADD_SPLIT_KERNEL_PROGRAM(kernel_name) \\
    const string program_name_##kernel_name = ""split_"" #kernel_name; \\
    program_##kernel_name = OpenCLDevice::OpenCLProgram( \\
        device, \\
        program_name_##kernel_name, \\
        ""kernel_"" #kernel_name "".cl"", \\
        device->get_build_options(requested_features, program_name_##kernel_name, is_preview)); \\
    program_##kernel_name.add_kernel(ustring(""path_trace_"" #kernel_name)); \\
    programs.push_back(&program_##kernel_name);

    /* Ordered with most complex kernels first, to reduce overall compile time. */
    ADD_SPLIT_KERNEL_PROGRAM(subsurface_scatter);
    if (requested_features.use_volume || is_preview) {
      ADD_SPLIT_KERNEL_PROGRAM(do_volume);
    }
    ADD_SPLIT_KERNEL_PROGRAM(shadow_blocked_dl);
    ADD_SPLIT_KERNEL_PROGRAM(shadow_blocked_ao);
    ADD_SPLIT_KERNEL_PROGRAM(holdout_emission_blurring_pathtermination_ao);
    ADD_SPLIT_KERNEL_PROGRAM(lamp_emission);
    ADD_SPLIT_KERNEL_PROGRAM(direct_lighting);
    ADD_SPLIT_KERNEL_PROGRAM(indirect_background);
    ADD_SPLIT_KERNEL_PROGRAM(shader_eval);

    /* Quick kernels bundled in a single program to reduce overhead of starting
     * Blender processes. */
    program_split = OpenCLDevice::OpenCLProgram(
        device,
        ""split_bundle"",
        ""kernel_split_bundle.cl"",
        device->get_build_options(requested_features, ""split_bundle"", is_preview));

    ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(data_init);
    ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(state_buffer_size);
    ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(path_init);
    ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(scene_intersect);
    ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(queue_enqueue);
    ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(shader_setup);
    ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(shader_sort);
    ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(enqueue_inactive);
    ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(next_iteration_setup);
    ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(indirect_subsurface);
    ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(buffer_update);
    programs.push_back(&program_split);

#  undef ADD_SPLIT_KERNEL_PROGRAM
#  undef ADD_SPLIT_KERNEL_BUNDLE_PROGRAM
  }
}

namespace {

/* Copy dummy KernelGlobals related to OpenCL from kernel_globals.h to
 * fetch its size.
 */
typedef struct KernelGlobalsDummy {
  ccl_constant KernelData *data;
  ccl_global char *buffers[8];

#  define KERNEL_TEX(type, name) TextureInfo name;
#  include ""kernel/kernel_textures.h""
#  undef KERNEL_TEX
  SplitData split_data;
  SplitParams split_param_data;
} KernelGlobalsDummy;

}  // namespace

struct CachedSplitMemory {
  int id;
  device_memory *split_data;
  device_memory *ray_state;
  device_memory *queue_index;
  device_memory *use_queues_flag;
  device_memory *work_pools;
  device_ptr *buffer;
};

class OpenCLSplitKernelFunction : public SplitKernelFunction {
 public:
  OpenCLDevice *device;
  OpenCLDevice::OpenCLProgram program;
  CachedSplitMemory &cached_memory;
  int cached_id;

  OpenCLSplitKernelFunction(OpenCLDevice *device, CachedSplitMemory &cached_memory)
      : device(device), cached_memory(cached_memory), cached_id(cached_memory.id - 1)
  {
  }

  ~OpenCLSplitKernelFunction()
  {
    program.release();
  }

  virtual bool enqueue(const KernelDimensions &dim, device_memory &kg, device_memory &data)
  {
    if (cached_id != cached_memory.id) {
      cl_uint start_arg_index = device->kernel_set_args(
          program(), 0, kg, data, *cached_memory.split_data, *cached_memory.ray_state);

      device->set_kernel_arg_buffers(program(), &start_arg_index);

      start_arg_index += device->kernel_set_args(program(),
                                                 start_arg_index,
                                                 *cached_memory.queue_index,
                                                 *cached_memory.use_queues_flag,
                                                 *cached_memory.work_pools,
                                                 *cached_memory.buffer);

      cached_id = cached_memory.id;
    }

    device->ciErr = clEnqueueNDRangeKernel(device->cqCommandQueue,
                                           program(),
                                           2,
                                           NULL,
                                           dim.global_size,
                                           dim.local_size,
                                           0,
                                           NULL,
                                           NULL);

    device->opencl_assert_err(device->ciErr, ""clEnqueueNDRangeKernel"");

    if (device->ciErr != CL_SUCCESS) {
      string message = string_printf(""OpenCL error: %s in clEnqueueNDRangeKernel()"",
                                     clewErrorString(device->ciErr));
      device->opencl_error(message);
      return false;
    }

    return true;
  }
};

class OpenCLSplitKernel : public DeviceSplitKernel {
  OpenCLDevice *device;
  CachedSplitMemory cached_memory;

 public:
  explicit OpenCLSplitKernel(OpenCLDevice *device) : DeviceSplitKernel(device), device(device)
  {
  }

  virtual SplitKernelFunction *get_split_kernel_function(
      const string &kernel_name, const DeviceRequestedFeatures &requested_features)
  {
    OpenCLSplitKernelFunction *kernel = new OpenCLSplitKernelFunction(device, cached_memory);

    const string program_name = device->get_opencl_program_name(kernel_name);
    kernel->program = OpenCLDevice::OpenCLProgram(
        device,
        program_name,
        device->get_opencl_program_filename(kernel_name),
        device->get_build_options(requested_features, program_name, device->use_preview_kernels));

    kernel->program.add_kernel(ustring(""path_trace_"" + kernel_name));
    kernel->program.load();

    if (!kernel->program.is_loaded()) {
      delete kernel;
      return NULL;
    }

    return kernel;
  }

  virtual uint64_t state_buffer_size(device_memory &kg, device_memory &data, size_t num_threads)
  {
    device_vector<uint64_t> size_buffer(device, ""size_buffer"", MEM_READ_WRITE);
    size_buffer.alloc(1);
    size_buffer.zero_to_device();

    uint threads = num_threads;
    OpenCLDevice::OpenCLSplitPrograms *programs = device->get_split_programs();
    cl_kernel kernel_state_buffer_size = programs->program_split(
        ustring(""path_trace_state_buffer_size""));
    device->kernel_set_args(kernel_state_buffer_size, 0, kg, data, threads, size_buffer);

    size_t global_size = 64;
    device->ciErr = clEnqueueNDRangeKernel(device->cqCommandQueue,
                                           kernel_state_buffer_size,
                                           1,
                                           NULL,
                                           &global_size,
                                           NULL,
                                           0,
                                           NULL,
                                           NULL);

    device->opencl_assert_err(device->ciErr, ""clEnqueueNDRangeKernel"");

    size_buffer.copy_from_device(0, 1, 1);
    size_t size = size_buffer[0];
    size_buffer.free();

    if (device->ciErr != CL_SUCCESS) {
      string message = string_printf(""OpenCL error: %s in clEnqueueNDRangeKernel()"",
                                     clewErrorString(device->ciErr));
      device->opencl_error(message);
      return 0;
    }

    return size;
  }

  virtual bool enqueue_split_kernel_data_init(const KernelDimensions &dim,
                                              RenderTile &rtile,
                                              int num_global_elements,
                                              device_memory &kernel_globals,
                                              device_memory &kernel_data,
                                              device_memory &split_data,
                                              device_memory &ray_state,
                                              device_memory &queue_index,
                                              device_memory &use_queues_flag,
                                              device_memory &work_pool_wgs)
  {
    cl_int dQueue_size = dim.global_size[0] * dim.global_size[1];

    /* Set the range of samples to be processed for every ray in
     * path-regeneration logic.
     */
    cl_int start_sample = rtile.start_sample;
    cl_int end_sample = rtile.start_sample + rtile.num_samples;

    OpenCLDevice::OpenCLSplitPrograms *programs = device->get_split_programs();
    cl_kernel kernel_data_init = programs->program_split(ustring(""path_trace_data_init""));

    cl_uint start_arg_index = device->kernel_set_args(kernel_data_init,
                                                      0,
                                                      kernel_globals,
                                                      kernel_data,
                                                      split_data,
                                                      num_global_elements,
                                                      ray_state);

    device->set_kernel_arg_buffers(kernel_data_init, &start_arg_index);

    start_arg_index += device->kernel_set_args(kernel_data_init,
                                               start_arg_index,
                                               start_sample,
                                               end_sample,
                                               rtile.x,
                                               rtile.y,
                                               rtile.w,
                                               rtile.h,
                                               rtile.offset,
                                               rtile.stride,
                                               queue_index,
                                               dQueue_size,
                                               use_queues_flag,
                                               work_pool_wgs,
                                               rtile.num_samples,
                                               rtile.buffer);

    /* Enqueue ckPathTraceKernel_data_init kernel. */
    device->ciErr = clEnqueueNDRangeKernel(device->cqCommandQueue,
                                           kernel_data_init,
                                           2,
                                           NULL,
                                           dim.global_size,
                                           dim.local_size,
                                           0,
                                           NULL,
                                           NULL);

    device->opencl_assert_err(device->ciErr, ""clEnqueueNDRangeKernel"");

    if (device->ciErr != CL_SUCCESS) {
      string message = string_printf(""OpenCL error: %s in clEnqueueNDRangeKernel()"",
                                     clewErrorString(device->ciErr));
      device->opencl_error(message);
      return false;
    }

    cached_memory.split_data = &split_data;
    cached_memory.ray_state = &ray_state;
    cached_memory.queue_index = &queue_index;
    cached_memory.use_queues_flag = &use_queues_flag;
    cached_memory.work_pools = &work_pool_wgs;
    cached_memory.buffer = &rtile.buffer;
    cached_memory.id++;

    return true;
  }

  virtual int2 split_kernel_local_size()
  {
    return make_int2(64, 1);
  }

  virtual int2 split_kernel_global_size(device_memory &kg,
                                        device_memory &data,
                                        DeviceTask * /*task*/)
  {
    cl_device_type type = OpenCLInfo::get_device_type(device->cdDevice);
    /* Use small global size on CPU devices as it seems to be much faster. */
    if (type == CL_DEVICE_TYPE_CPU) {
      VLOG(1) << ""Global size: (64, 64)."";
      return make_int2(64, 64);
    }

    cl_ulong max_buffer_size;
    clGetDeviceInfo(
        device->cdDevice, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof(cl_ulong), &max_buffer_size, NULL);

    if (DebugFlags().opencl.mem_limit) {
      max_buffer_size = min(max_buffer_size,
                            cl_ulong(DebugFlags().opencl.mem_limit - device->stats.mem_used));
    }

    VLOG(1) << ""Maximum device allocation size: "" << string_human_readable_number(max_buffer_size)
            << "" bytes. ("" << string_human_readable_size(max_buffer_size) << "")."";

    /* Limit to 2gb, as we shouldn't need more than that and some devices may support much more. */
    max_buffer_size = min(max_buffer_size / 2, (cl_ulong)2l * 1024 * 1024 * 1024);

    size_t num_elements = max_elements_for_max_buffer_size(kg, data, max_buffer_size);
    int2 global_size = make_int2(max(round_down((int)sqrt(num_elements), 64), 64),
                                 (int)sqrt(num_elements));
    VLOG(1) << ""Global size: "" << global_size << ""."";
    return global_size;
  }
};

bool OpenCLDevice::opencl_error(cl_int err)
{
  if (err != CL_SUCCESS) {
    string message = string_printf(""OpenCL error (%d): %s"", err, clewErrorString(err));
    if (error_msg == """")
      error_msg = message;
    fprintf(stderr, ""%s\\n"", message.c_str());
    return true;
  }

  return false;
}

void OpenCLDevice::opencl_error(const string &message)
{
  if (error_msg == """")
    error_msg = message;
  fprintf(stderr, ""%s\\n"", message.c_str());
}

void OpenCLDevice::opencl_assert_err(cl_int err, const char *where)
{
  if (err != CL_SUCCESS) {
    string message = string_printf(
        ""OpenCL error (%d): %s in %s"", err, clewErrorString(err), where);
    if (error_msg == """")
      error_msg = message;
    fprintf(stderr, ""%s\\n"", message.c_str());
#  ifndef NDEBUG
    abort();
#  endif
  }
}

OpenCLDevice::OpenCLDevice(DeviceInfo &info, Stats &stats, Profiler &profiler, bool background)
    : Device(info, stats, profiler, background),
      kernel_programs(this),
      preview_programs(this),
      memory_manager(this),
      texture_info(this, ""__texture_info"", MEM_TEXTURE)
{
  cpPlatform = NULL;
  cdDevice = NULL;
  cxContext = NULL;
  cqCommandQueue = NULL;
  null_mem = 0;
  device_initialized = false;
  textures_need_update = true;
  use_preview_kernels = !background;

  vector<OpenCLPlatformDevice> usable_devices;
  OpenCLInfo::get_usable_devices(&usable_devices);
  if (usable_devices.size() == 0) {
    opencl_error(""OpenCL: no devices found."");
    return;
  }
  assert(info.num < usable_devices.size());
  OpenCLPlatformDevice &platform_device = usable_devices[info.num];
  device_num = info.num;
  cpPlatform = platform_device.platform_id;
  cdDevice = platform_device.device_id;
  platform_name = platform_device.platform_name;
  device_name = platform_device.device_name;
  VLOG(2) << ""Creating new Cycles device for OpenCL platform "" << platform_name << "", device ""
          << device_name << ""."";

  {
    /* try to use cached context */
    thread_scoped_lock cache_locker;
    cxContext = OpenCLCache::get_context(cpPlatform, cdDevice, cache_locker);

    if (cxContext == NULL) {
      /* create context properties array to specify platform */
      const cl_context_properties context_props[] = {
          CL_CONTEXT_PLATFORM, (cl_context_properties)cpPlatform, 0, 0};

      /* create context */
      cxContext = clCreateContext(
          context_props, 1, &cdDevice, context_notify_callback, cdDevice, &ciErr);

      if (opencl_error(ciErr)) {
        opencl_error(""OpenCL: clCreateContext failed"");
        return;
      }

      /* cache it */
      OpenCLCache::store_context(cpPlatform, cdDevice, cxContext, cache_locker);
    }
  }

  cqCommandQueue = clCreateCommandQueue(cxContext, cdDevice, 0, &ciErr);
  if (opencl_error(ciErr)) {
    opencl_error(""OpenCL: Error creating command queue"");
    return;
  }

  null_mem = (device_ptr)clCreateBuffer(cxContext, CL_MEM_READ_ONLY, 1, NULL, &ciErr);
  if (opencl_error(ciErr)) {
    opencl_error(""OpenCL: Error creating memory buffer for NULL"");
    return;
  }

  /* Allocate this right away so that texture_info
   * is placed at offset 0 in the device memory buffers. */
  texture_info.resize(1);
  memory_manager.alloc(""texture_info"", texture_info);

  device_initialized = true;

  split_kernel = new OpenCLSplitKernel(this);
  if (!background) {
    load_preview_kernels();
  }
}

OpenCLDevice::~OpenCLDevice()
{
  task_pool.stop();
  load_required_kernel_task_pool.stop();
  load_kernel_task_pool.stop();

  memory_manager.free();

  if (null_mem)
    clReleaseMemObject(CL_MEM_PTR(null_mem));

  ConstMemMap::iterator mt;
  for (mt = const_mem_map.begin(); mt != const_mem_map.end(); mt++) {
    delete mt->second;
  }

  base_program.release();
  bake_program.release();
  displace_program.release();
  background_program.release();
  denoising_program.release();

  if (cqCommandQueue)
    clReleaseCommandQueue(cqCommandQueue);
  if (cxContext)
    clReleaseContext(cxContext);

  delete split_kernel;
}

void CL_CALLBACK OpenCLDevice::context_notify_callback(const char *err_info,
                                                       const void * /*private_info*/,
                                                       size_t /*cb*/,
                                                       void *user_data)
{
  string device_name = OpenCLInfo::get_device_name((cl_device_id)user_data);
  fprintf(stderr, ""OpenCL error (%s): %s\\n"", device_name.c_str(), err_info);
}

bool OpenCLDevice::opencl_version_check()
{
  string error;
  if (!OpenCLInfo::platform_version_check(cpPlatform, &error)) {
    opencl_error(error);
    return false;
  }
  if (!OpenCLInfo::device_version_check(cdDevice, &error)) {
    opencl_error(error);
    return false;
  }
  return true;
}

string OpenCLDevice::device_md5_hash(string kernel_custom_build_options)
{
  MD5Hash md5;
  char version[256], driver[256], name[256], vendor[256];

  clGetPlatformInfo(cpPlatform, CL_PLATFORM_VENDOR, sizeof(vendor), &vendor, NULL);
  clGetDeviceInfo(cdDevice, CL_DEVICE_VERSION, sizeof(version), &version, NULL);
  clGetDeviceInfo(cdDevice, CL_DEVICE_NAME, sizeof(name), &name, NULL);
  clGetDeviceInfo(cdDevice, CL_DRIVER_VERSION, sizeof(driver), &driver, NULL);

  md5.append((uint8_t *)vendor, strlen(vendor));
  md5.append((uint8_t *)version, strlen(version));
  md5.append((uint8_t *)name, strlen(name));
  md5.append((uint8_t *)driver, strlen(driver));

  string options = kernel_build_options();
  options += kernel_custom_build_options;
  md5.append((uint8_t *)options.c_str(), options.size());

  return md5.get_hex();
}

bool OpenCLDevice::load_kernels(const DeviceRequestedFeatures &requested_features)
{
  VLOG(2) << ""Loading kernels for platform "" << platform_name << "", device "" << device_name << ""."";
  /* Verify if device was initialized. */
  if (!device_initialized) {
    fprintf(stderr, ""OpenCL: failed to initialize device.\\n"");
    return false;
  }

  /* Verify we have right opencl version. */
  if (!opencl_version_check())
    return false;

  load_required_kernels(requested_features);

  vector<OpenCLProgram *> programs;
  kernel_programs.load_kernels(programs, requested_features, false);

  if (!requested_features.use_baking && requested_features.use_denoising) {
    denoising_program = OpenCLProgram(
        this, ""denoising"", ""filter.cl"", get_build_options(requested_features, ""denoising""));
    denoising_program.add_kernel(ustring(""filter_divide_shadow""));
    denoising_program.add_kernel(ustring(""filter_get_feature""));
    denoising_program.add_kernel(ustring(""filter_write_feature""));
    denoising_program.add_kernel(ustring(""filter_detect_outliers""));
    denoising_program.add_kernel(ustring(""filter_combine_halves""));
    denoising_program.add_kernel(ustring(""filter_construct_transform""));
    denoising_program.add_kernel(ustring(""filter_nlm_calc_difference""));
    denoising_program.add_kernel(ustring(""filter_nlm_blur""));
    denoising_program.add_kernel(ustring(""filter_nlm_calc_weight""));
    denoising_program.add_kernel(ustring(""filter_nlm_update_output""));
    denoising_program.add_kernel(ustring(""filter_nlm_normalize""));
    denoising_program.add_kernel(ustring(""filter_nlm_construct_gramian""));
    denoising_program.add_kernel(ustring(""filter_finalize""));
    programs.push_back(&denoising_program);
  }

  load_required_kernel_task_pool.wait_work();

  /* Parallel compilation of Cycles kernels, this launches multiple
   * processes to workaround OpenCL frameworks serializing the calls
   * internally within a single process. */
  foreach (OpenCLProgram *program, programs) {
    if (!program->load()) {
      load_kernel_task_pool.push(function_bind(&OpenCLProgram::compile, program));
    }
  }
  return true;
}

void OpenCLDevice::load_required_kernels(const DeviceRequestedFeatures &requested_features)
{
  vector<OpenCLProgram *> programs;
  base_program = OpenCLProgram(
      this, ""base"", ""kernel_base.cl"", get_build_options(requested_features, ""base""));
  base_program.add_kernel(ustring(""convert_to_byte""));
  base_program.add_kernel(ustring(""convert_to_half_float""));
  base_program.add_kernel(ustring(""zero_buffer""));
  programs.push_back(&base_program);

  if (requested_features.use_true_displacement) {
    displace_program = OpenCLProgram(
        this, ""displace"", ""kernel_displace.cl"", get_build_options(requested_features, ""displace""));
    displace_program.add_kernel(ustring(""displace""));
    programs.push_back(&displace_program);
  }

  if (requested_features.use_background_light) {
    background_program = OpenCLProgram(this,
                                       ""background"",
                                       ""kernel_background.cl"",
                                       get_build_options(requested_features, ""background""));
    background_program.add_kernel(ustring(""background""));
    programs.push_back(&background_program);
  }

  if (requested_features.use_baking) {
    bake_program = OpenCLProgram(
        this, ""bake"", ""kernel_bake.cl"", get_build_options(requested_features, ""bake""));
    bake_program.add_kernel(ustring(""bake""));
    programs.push_back(&bake_program);
  }

  foreach (OpenCLProgram *program, programs) {
    if (!program->load()) {
      load_required_kernel_task_pool.push(function_bind(&OpenCLProgram::compile, program));
    }
  }
}

void OpenCLDevice::load_preview_kernels()
{
  DeviceRequestedFeatures no_features;
  vector<OpenCLProgram *> programs;
  preview_programs.load_kernels(programs, no_features, true);

  foreach (OpenCLProgram *program, programs) {
    if (!program->load()) {
      load_required_kernel_task_pool.push(function_bind(&OpenCLProgram::compile, program));
    }
  }
}

bool OpenCLDevice::wait_for_availability(const DeviceRequestedFeatures &requested_features)
{
  if (background) {
    load_kernel_task_pool.wait_work();
    use_preview_kernels = false;
  }
  else {
    /* We use a device setting to determine to load preview kernels or not
     * Better to check on device level than per kernel as mixing preview and
     * non-preview kernels does not work due to different data types */
    if (use_preview_kernels) {
      use_preview_kernels = !load_kernel_task_pool.finished();
    }
  }
  return split_kernel->load_kernels(requested_features);
}

OpenCLDevice::OpenCLSplitPrograms *OpenCLDevice::get_split_programs()
{
  return use_preview_kernels ? &preview_programs : &kernel_programs;
}

DeviceKernelStatus OpenCLDevice::get_active_kernel_switch_state()
{
  /* Do not switch kernels for background renderings
   * We do foreground rendering but use the preview kernels
   * Check for the optimized kernels
   *
   * This works also the other way around, where we are using
   * optimized kernels but new ones are being compiled due
   * to other features that are needed */
  if (background) {
    /* The if-statements below would find the same result,
     * But as the `finished` method uses a mutex we added
     * this as an early exit */
    return DEVICE_KERNEL_USING_FEATURE_KERNEL;
  }

  bool other_kernels_finished = load_kernel_task_pool.finished();
  if (use_preview_kernels) {
    if (other_kernels_finished) {
      return DEVICE_KERNEL_FEATURE_KERNEL_AVAILABLE;
    }
    else {
      return DEVICE_KERNEL_WAITING_FOR_FEATURE_KERNEL;
    }
  }
  else {
    if (other_kernels_finished) {
      return DEVICE_KERNEL_USING_FEATURE_KERNEL;
    }
    else {
      return DEVICE_KERNEL_FEATURE_KERNEL_INVALID;
    }
  }
}

void OpenCLDevice::mem_alloc(device_memory &mem)
{
  if (mem.name) {
    VLOG(1) << ""Buffer allocate: "" << mem.name << "", ""
            << string_human_readable_number(mem.memory_size()) << "" bytes. (""
            << string_human_readable_size(mem.memory_size()) << "")"";
  }

  size_t size = mem.memory_size();

  /* check there is enough memory available for the allocation */
  cl_ulong max_alloc_size = 0;
  clGetDeviceInfo(cdDevice, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof(cl_ulong), &max_alloc_size, NULL);

  if (DebugFlags().opencl.mem_limit) {
    max_alloc_size = min(max_alloc_size, cl_ulong(DebugFlags().opencl.mem_limit - stats.mem_used));
  }

  if (size > max_alloc_size) {
    string error = ""Scene too complex to fit in available memory."";
    if (mem.name != NULL) {
      error += string_printf("" (allocating buffer %s failed.)"", mem.name);
    }
    set_error(error);

    return;
  }

  cl_mem_flags mem_flag;
  void *mem_ptr = NULL;

  if (mem.type == MEM_READ_ONLY || mem.type == MEM_TEXTURE)
    mem_flag = CL_MEM_READ_ONLY;
  else
    mem_flag = CL_MEM_READ_WRITE;

  /* Zero-size allocation might be invoked by render, but not really
   * supported by OpenCL. Using NULL as device pointer also doesn't really
   * work for some reason, so for the time being we'll use special case
   * will null_mem buffer.
   */
  if (size != 0) {
    mem.device_pointer = (device_ptr)clCreateBuffer(cxContext, mem_flag, size, mem_ptr, &ciErr);
    opencl_assert_err(ciErr, ""clCreateBuffer"");
  }
  else {
    mem.device_pointer = null_mem;
  }

  stats.mem_alloc(size);
  mem.device_size = size;
}

void OpenCLDevice::mem_copy_to(device_memory &mem)
{
  if (mem.type == MEM_TEXTURE) {
    tex_free(mem);
    tex_alloc(mem);
  }
  else {
    if (!mem.device_pointer) {
      mem_alloc(mem);
    }

    /* this is blocking */
    size_t size = mem.memory_size();
    if (size != 0) {
      opencl_assert(clEnqueueWriteBuffer(cqCommandQueue,
                                         CL_MEM_PTR(mem.device_pointer),
                                         CL_TRUE,
                                         0,
                                         size,
                                         mem.host_pointer,
                                         0,
                                         NULL,
                                         NULL));
    }
  }
}

void OpenCLDevice::mem_copy_from(device_memory &mem, int y, int w, int h, int elem)
{
  size_t offset = elem * y * w;
  size_t size = elem * w * h;
  assert(size != 0);
  opencl_assert(clEnqueueReadBuffer(cqCommandQueue,
                                    CL_MEM_PTR(mem.device_pointer),
                                    CL_TRUE,
                                    offset,
                                    size,
                                    (uchar *)mem.host_pointer + offset,
                                    0,
                                    NULL,
                                    NULL));
}

void OpenCLDevice::mem_zero_kernel(device_ptr mem, size_t size)
{
  base_program.wait_for_availability();
  cl_kernel ckZeroBuffer = base_program(ustring(""zero_buffer""));

  size_t global_size[] = {1024, 1024};
  size_t num_threads = global_size[0] * global_size[1];

  cl_mem d_buffer = CL_MEM_PTR(mem);
  cl_ulong d_offset = 0;
  cl_ulong d_size = 0;

  while (d_offset < size) {
    d_size = std::min<cl_ulong>(num_threads * sizeof(float4), size - d_offset);

    kernel_set_args(ckZeroBuffer, 0, d_buffer, d_size, d_offset);

    ciErr = clEnqueueNDRangeKernel(
        cqCommandQueue, ckZeroBuffer, 2, NULL, global_size, NULL, 0, NULL, NULL);
    opencl_assert_err(ciErr, ""clEnqueueNDRangeKernel"");

    d_offset += d_size;
  }
}

void OpenCLDevice::mem_zero(device_memory &mem)
{
  if (!mem.device_pointer) {
    mem_alloc(mem);
  }

  if (mem.device_pointer) {
    if (base_program.is_loaded()) {
      mem_zero_kernel(mem.device_pointer, mem.memory_size());
    }

    if (mem.host_pointer) {
      memset(mem.host_pointer, 0, mem.memory_size());
    }

    if (!base_program.is_loaded()) {
      void *zero = mem.host_pointer;

      if (!mem.host_pointer) {
        zero = util_aligned_malloc(mem.memory_size(), 16);
        memset(zero, 0, mem.memory_size());
      }

      opencl_assert(clEnqueueWriteBuffer(cqCommandQueue,
                                         CL_MEM_PTR(mem.device_pointer),
                                         CL_TRUE,
                                         0,
                                         mem.memory_size(),
                                         zero,
                                         0,
                                         NULL,
                                         NULL));

      if (!mem.host_pointer) {
        util_aligned_free(zero);
      }
    }
  }
}

void OpenCLDevice::mem_free(device_memory &mem)
{
  if (mem.type == MEM_TEXTURE) {
    tex_free(mem);
  }
  else {
    if (mem.device_pointer) {
      if (mem.device_pointer != null_mem) {
        opencl_assert(clReleaseMemObject(CL_MEM_PTR(mem.device_pointer)));
      }
      mem.device_pointer = 0;

      stats.mem_free(mem.device_size);
      mem.device_size = 0;
    }
  }
}

int OpenCLDevice::mem_sub_ptr_alignment()
{
  return OpenCLInfo::mem_sub_ptr_alignment(cdDevice);
}

device_ptr OpenCLDevice::mem_alloc_sub_ptr(device_memory &mem, int offset, int size)
{
  cl_mem_flags mem_flag;
  if (mem.type == MEM_READ_ONLY || mem.type == MEM_TEXTURE)
    mem_flag = CL_MEM_READ_ONLY;
  else
    mem_flag = CL_MEM_READ_WRITE;

  cl_buffer_region info;
  info.origin = mem.memory_elements_size(offset);
  info.size = mem.memory_elements_size(size);

  device_ptr sub_buf = (device_ptr)clCreateSubBuffer(
      CL_MEM_PTR(mem.device_pointer), mem_flag, CL_BUFFER_CREATE_TYPE_REGION, &info, &ciErr);
  opencl_assert_err(ciErr, ""clCreateSubBuffer"");
  return sub_buf;
}

void OpenCLDevice::mem_free_sub_ptr(device_ptr device_pointer)
{
  if (device_pointer && device_pointer != null_mem) {
    opencl_assert(clReleaseMemObject(CL_MEM_PTR(device_pointer)));
  }
}

void OpenCLDevice::const_copy_to(const char *name, void *host, size_t size)
{
  ConstMemMap::iterator i = const_mem_map.find(name);
  device_vector<uchar> *data;

  if (i == const_mem_map.end()) {
    data = new device_vector<uchar>(this, name, MEM_READ_ONLY);
    data->alloc(size);
    const_mem_map.insert(ConstMemMap::value_type(name, data));
  }
  else {
    data = i->second;
  }

  memcpy(data->data(), host, size);
  data->copy_to_device();
}

void OpenCLDevice::tex_alloc(device_memory &mem)
{
  VLOG(1) << ""Texture allocate: "" << mem.name << "", ""
          << string_human_readable_number(mem.memory_size()) << "" bytes. (""
          << string_human_readable_size(mem.memory_size()) << "")"";

  memory_manager.alloc(mem.name, mem);
  /* Set the pointer to non-null to keep code that inspects its value from thinking its
   * unallocated. */
  mem.device_pointer = 1;
  textures[mem.name] = &mem;
  textures_need_update = true;
}

void OpenCLDevice::tex_free(device_memory &mem)
{
  if (mem.device_pointer) {
    mem.device_pointer = 0;

    if (memory_manager.free(mem)) {
      textures_need_update = true;
    }

    foreach (TexturesMap::value_type &value, textures) {
      if (value.second == &mem) {
        textures.erase(value.first);
        break;
      }
    }
  }
}

size_t OpenCLDevice::global_size_round_up(int group_size, int global_size)
{
  int r = global_size % group_size;
  return global_size + ((r == 0) ? 0 : group_size - r);
}

void OpenCLDevice::enqueue_kernel(
    cl_kernel kernel, size_t w, size_t h, bool x_workgroups, size_t max_workgroup_size)
{
  size_t workgroup_size, max_work_items[3];

  clGetKernelWorkGroupInfo(
      kernel, cdDevice, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
  clGetDeviceInfo(
      cdDevice, CL_DEVICE_MAX_WORK_ITEM_SIZES, sizeof(size_t) * 3, max_work_items, NULL);

  if (max_workgroup_size > 0 && workgroup_size > max_workgroup_size) {
    workgroup_size = max_workgroup_size;
  }

  /* Try to divide evenly over 2 dimensions. */
  size_t local_size[2];
  if (x_workgroups) {
    local_size[0] = workgroup_size;
    local_size[1] = 1;
  }
  else {
    size_t sqrt_workgroup_size = max((size_t)sqrt((double)workgroup_size), 1);
    local_size[0] = local_size[1] = sqrt_workgroup_size;
  }

  /* Some implementations have max size 1 on 2nd dimension. */
  if (local_size[1] > max_work_items[1]) {
    local_size[0] = workgroup_size / max_work_items[1];
    local_size[1] = max_work_items[1];
  }

  size_t global_size[2] = {global_size_round_up(local_size[0], w),
                           global_size_round_up(local_size[1], h)};

  /* Vertical size of 1 is coming from bake/shade kernels where we should
   * not round anything up because otherwise we'll either be doing too
   * much work per pixel (if we don't check global ID on Y axis) or will
   * be checking for global ID to always have Y of 0.
   */
  if (h == 1) {
    global_size[h] = 1;
  }

  /* run kernel */
  opencl_assert(
      clEnqueueNDRangeKernel(cqCommandQueue, kernel, 2, NULL, global_size, NULL, 0, NULL, NULL));
  opencl_assert(clFlush(cqCommandQueue));
}

void OpenCLDevice::set_kernel_arg_mem(cl_kernel kernel, cl_uint *narg, const char *name)
{
  cl_mem ptr;

  MemMap::iterator i = mem_map.find(name);
  if (i != mem_map.end()) {
    ptr = CL_MEM_PTR(i->second);
  }
  else {
    /* work around NULL not working, even though the spec says otherwise */
    ptr = CL_MEM_PTR(null_mem);
  }

  opencl_assert(clSetKernelArg(kernel, (*narg)++, sizeof(ptr), (void *)&ptr));
}

void OpenCLDevice::set_kernel_arg_buffers(cl_kernel kernel, cl_uint *narg)
{
  flush_texture_buffers();

  memory_manager.set_kernel_arg_buffers(kernel, narg);
}

void OpenCLDevice::flush_texture_buffers()
{
  if (!textures_need_update) {
    return;
  }
  textures_need_update = false;

  /* Setup slots for textures. */
  int num_slots = 0;

  vector<texture_slot_t> texture_slots;

#  define KERNEL_TEX(type, name) \\
    if (textures.find(#name) != textures.end()) { \\
      texture_slots.push_back(texture_slot_t(#name, num_slots)); \\
    } \\
    num_slots++;
#  include ""kernel/kernel_textures.h""

  int num_data_slots = num_slots;

  foreach (TexturesMap::value_type &tex, textures) {
    string name = tex.first;

    if (string_startswith(name, ""__tex_image"")) {
      int pos = name.rfind(""_"");
      int id = atoi(name.data() + pos + 1);
      texture_slots.push_back(texture_slot_t(name, num_data_slots + id));
      num_slots = max(num_slots, num_data_slots + id + 1);
    }
  }

  /* Realloc texture descriptors buffer. */
  memory_manager.free(texture_info);
  texture_info.resize(num_slots);
  memory_manager.alloc(""texture_info"", texture_info);

  /* Fill in descriptors */
  foreach (texture_slot_t &slot, texture_slots) {
    TextureInfo &info = texture_info[slot.slot];

    MemoryManager::BufferDescriptor desc = memory_manager.get_descriptor(slot.name);
    info.data = desc.offset;
    info.cl_buffer = desc.device_buffer;

    if (string_startswith(slot.name, ""__tex_image"")) {
      device_memory *mem = textures[slot.name];

      info.width = mem->data_width;
      info.height = mem->data_height;
      info.depth = mem->data_depth;

      info.interpolation = mem->interpolation;
      info.extension = mem->extension;
    }
  }

  /* Force write of descriptors. */
  memory_manager.free(texture_info);
  memory_manager.alloc(""texture_info"", texture_info);
}

void OpenCLDevice::thread_run(DeviceTask *task)
{
  flush_texture_buffers();

  if (task->type == DeviceTask::FILM_CONVERT) {
    film_convert(*task, task->buffer, task->rgba_byte, task->rgba_half);
  }
  else if (task->type == DeviceTask::SHADER) {
    shader(*task);
  }
  else if (task->type == DeviceTask::RENDER) {
    RenderTile tile;
    DenoisingTask denoising(this, *task);

    /* Allocate buffer for kernel globals */
    device_only_memory<KernelGlobalsDummy> kgbuffer(this, ""kernel_globals"");
    kgbuffer.alloc_to_device(1);

    /* Keep rendering tiles until done. */
    while (task->acquire_tile(this, tile)) {
      if (tile.task == RenderTile::PATH_TRACE) {
        assert(tile.task == RenderTile::PATH_TRACE);
        scoped_timer timer(&tile.buffers->render_time);

        split_kernel->path_trace(task, tile, kgbuffer, *const_mem_map[""__data""]);

        /* Complete kernel execution before release tile. */
        /* This helps in multi-device render;
         * The device that reaches the critical-section function
         * release_tile waits (stalling other devices from entering
         * release_tile) for all kernels to complete. If device1 (a
         * slow-render device) reaches release_tile first then it would
         * stall device2 (a fast-render device) from proceeding to render
         * next tile.
         */
        clFinish(cqCommandQueue);
      }
      else if (tile.task == RenderTile::DENOISE) {
        tile.sample = tile.start_sample + tile.num_samples;
        denoise(tile, denoising);
        task->update_progress(&tile, tile.w * tile.h);
      }

      task->release_tile(tile);
    }

    kgbuffer.free();
  }
}

void OpenCLDevice::film_convert(DeviceTask &task,
                                device_ptr buffer,
                                device_ptr rgba_byte,
                                device_ptr rgba_half)
{
  /* cast arguments to cl types */
  cl_mem d_data = CL_MEM_PTR(const_mem_map[""__data""]->device_pointer);
  cl_mem d_rgba = (rgba_byte) ? CL_MEM_PTR(rgba_byte) : CL_MEM_PTR(rgba_half);
  cl_mem d_buffer = CL_MEM_PTR(buffer);
  cl_int d_x = task.x;
  cl_int d_y = task.y;
  cl_int d_w = task.w;
  cl_int d_h = task.h;
  cl_float d_sample_scale = 1.0f / (task.sample + 1);
  cl_int d_offset = task.offset;
  cl_int d_stride = task.stride;

  cl_kernel ckFilmConvertKernel = (rgba_byte) ? base_program(ustring(""convert_to_byte"")) :
                                                base_program(ustring(""convert_to_half_float""));

  cl_uint start_arg_index = kernel_set_args(ckFilmConvertKernel, 0, d_data, d_rgba, d_buffer);

  set_kernel_arg_buffers(ckFilmConvertKernel, &start_arg_index);

  start_arg_index += kernel_set_args(ckFilmConvertKernel,
                                     start_arg_index,
                                     d_sample_scale,
                                     d_x,
                                     d_y,
                                     d_w,
                                     d_h,
                                     d_offset,
                                     d_stride);

  enqueue_kernel(ckFilmConvertKernel, d_w, d_h);
}

bool OpenCLDevice::denoising_non_local_means(device_ptr image_ptr,
                                             device_ptr guide_ptr,
                                             device_ptr variance_ptr,
                                             device_ptr out_ptr,
                                             DenoisingTask *task)
{
  int stride = task->buffer.stride;
  int w = task->buffer.width;
  int h = task->buffer.h;
  int r = task->nlm_state.r;
  int f = task->nlm_state.f;
  float a = task->nlm_state.a;
  float k_2 = task->nlm_state.k_2;

  int pass_stride = task->buffer.pass_stride;
  int num_shifts = (2 * r + 1) * (2 * r + 1);
  int channel_offset = task->nlm_state.is_color ? task->buffer.pass_stride : 0;

  device_sub_ptr difference(task->buffer.temporary_mem, 0, pass_stride * num_shifts);
  device_sub_ptr blurDifference(
      task->buffer.temporary_mem, pass_stride * num_shifts, pass_stride * num_shifts);
  device_sub_ptr weightAccum(
      task->buffer.temporary_mem, 2 * pass_stride * num_shifts, pass_stride);
  cl_mem weightAccum_mem = CL_MEM_PTR(*weightAccum);
  cl_mem difference_mem = CL_MEM_PTR(*difference);
  cl_mem blurDifference_mem = CL_MEM_PTR(*blurDifference);

  cl_mem image_mem = CL_MEM_PTR(image_ptr);
  cl_mem guide_mem = CL_MEM_PTR(guide_ptr);
  cl_mem variance_mem = CL_MEM_PTR(variance_ptr);
  cl_mem out_mem = CL_MEM_PTR(out_ptr);
  cl_mem scale_mem = NULL;

  mem_zero_kernel(*weightAccum, sizeof(float) * pass_stride);
  mem_zero_kernel(out_ptr, sizeof(float) * pass_stride);

  cl_kernel ckNLMCalcDifference = denoising_program(ustring(""filter_nlm_calc_difference""));
  cl_kernel ckNLMBlur = denoising_program(ustring(""filter_nlm_blur""));
  cl_kernel ckNLMCalcWeight = denoising_program(ustring(""filter_nlm_calc_weight""));
  cl_kernel ckNLMUpdateOutput = denoising_program(ustring(""filter_nlm_update_output""));
  cl_kernel ckNLMNormalize = denoising_program(ustring(""filter_nlm_normalize""));

  kernel_set_args(ckNLMCalcDifference,
                  0,
                  guide_mem,
                  variance_mem,
                  scale_mem,
                  difference_mem,
                  w,
                  h,
                  stride,
                  pass_stride,
                  r,
                  channel_offset,
                  0,
                  a,
                  k_2);
  kernel_set_args(
      ckNLMBlur, 0, difference_mem, blurDifference_mem, w, h, stride, pass_stride, r, f);
  kernel_set_args(
      ckNLMCalcWeight, 0, blurDifference_mem, difference_mem, w, h, stride, pass_stride, r, f);
  kernel_set_args(ckNLMUpdateOutput,
                  0,
                  blurDifference_mem,
                  image_mem,
                  out_mem,
                  weightAccum_mem,
                  w,
                  h,
                  stride,
                  pass_stride,
                  channel_offset,
                  r,
                  f);

  enqueue_kernel(ckNLMCalcDifference, w * h, num_shifts, true);
  enqueue_kernel(ckNLMBlur, w * h, num_shifts, true);
  enqueue_kernel(ckNLMCalcWeight, w * h, num_shifts, true);
  enqueue_kernel(ckNLMBlur, w * h, num_shifts, true);
  enqueue_kernel(ckNLMUpdateOutput, w * h, num_shifts, true);

  kernel_set_args(ckNLMNormalize, 0, out_mem, weightAccum_mem, w, h, stride);
  enqueue_kernel(ckNLMNormalize, w, h);

  return true;
}

bool OpenCLDevice::denoising_construct_transform(DenoisingTask *task)
{
  cl_mem buffer_mem = CL_MEM_PTR(task->buffer.mem.device_pointer);
  cl_mem transform_mem = CL_MEM_PTR(task->storage.transform.device_pointer);
  cl_mem rank_mem = CL_MEM_PTR(task->storage.rank.device_pointer);
  cl_mem tile_info_mem = CL_MEM_PTR(task->tile_info_mem.device_pointer);

  char use_time = task->buffer.use_time ? 1 : 0;

  cl_kernel ckFilterConstructTransform = denoising_program(ustring(""filter_construct_transform""));

  int arg_ofs = kernel_set_args(ckFilterConstructTransform, 0, buffer_mem, tile_info_mem);
  cl_mem buffers[9];
  for (int i = 0; i < 9; i++) {
    buffers[i] = CL_MEM_PTR(task->tile_info->buffers[i]);
    arg_ofs += kernel_set_args(ckFilterConstructTransform, arg_ofs, buffers[i]);
  }
  kernel_set_args(ckFilterConstructTransform,
                  arg_ofs,
                  transform_mem,
                  rank_mem,
                  task->filter_area,
                  task->rect,
                  task->buffer.pass_stride,
                  task->buffer.frame_stride,
                  use_time,
                  task->radius,
                  task->pca_threshold);

  enqueue_kernel(ckFilterConstructTransform, task->storage.w, task->storage.h, 256);

  return true;
}

bool OpenCLDevice::denoising_accumulate(device_ptr color_ptr,
                                        device_ptr color_variance_ptr,
                                        device_ptr scale_ptr,
                                        int frame,
                                        DenoisingTask *task)
{
  cl_mem color_mem = CL_MEM_PTR(color_ptr);
  cl_mem color_variance_mem = CL_MEM_PTR(color_variance_ptr);
  cl_mem scale_mem = CL_MEM_PTR(scale_ptr);

  cl_mem buffer_mem = CL_MEM_PTR(task->buffer.mem.device_pointer);
  cl_mem transform_mem = CL_MEM_PTR(task->storage.transform.device_pointer);
  cl_mem rank_mem = CL_MEM_PTR(task->storage.rank.device_pointer);
  cl_mem XtWX_mem = CL_MEM_PTR(task->storage.XtWX.device_pointer);
  cl_mem XtWY_mem = CL_MEM_PTR(task->storage.XtWY.device_pointer);

  cl_kernel ckNLMCalcDifference = denoising_program(ustring(""filter_nlm_calc_difference""));
  cl_kernel ckNLMBlur = denoising_program(ustring(""filter_nlm_blur""));
  cl_kernel ckNLMCalcWeight = denoising_program(ustring(""filter_nlm_calc_weight""));
  cl_kernel ckNLMConstructGramian = denoising_program(ustring(""filter_nlm_construct_gramian""));

  int w = task->reconstruction_state.source_w;
  int h = task->reconstruction_state.source_h;
  int stride = task->buffer.stride;
  int frame_offset = frame * task->buffer.frame_stride;
  int t = task->tile_info->frames[frame];
  char use_time = task->buffer.use_time ? 1 : 0;

  int r = task->radius;
  int pass_stride = task->buffer.pass_stride;
  int num_shifts = (2 * r + 1) * (2 * r + 1);

  device_sub_ptr difference(task->buffer.temporary_mem, 0, pass_stride * num_shifts);
  device_sub_ptr blurDifference(
      task->buffer.temporary_mem, pass_stride * num_shifts, pass_stride * num_shifts);
  cl_mem difference_mem = CL_MEM_PTR(*difference);
  cl_mem blurDifference_mem = CL_MEM_PTR(*blurDifference);

  kernel_set_args(ckNLMCalcDifference,
                  0,
                  color_mem,
                  color_variance_mem,
                  scale_mem,
                  difference_mem,
                  w,
                  h,
                  stride,
                  pass_stride,
                  r,
                  pass_stride,
                  frame_offset,
                  1.0f,
                  task->nlm_k_2);
  kernel_set_args(
      ckNLMBlur, 0, difference_mem, blurDifference_mem, w, h, stride, pass_stride, r, 4);
  kernel_set_args(
      ckNLMCalcWeight, 0, blurDifference_mem, difference_mem, w, h, stride, pass_stride, r, 4);
  kernel_set_args(ckNLMConstructGramian,
                  0,
                  t,
                  blurDifference_mem,
                  buffer_mem,
                  transform_mem,
                  rank_mem,
                  XtWX_mem,
                  XtWY_mem,
                  task->reconstruction_state.filter_window,
                  w,
                  h,
                  stride,
                  pass_stride,
                  r,
                  4,
                  frame_offset,
                  use_time);

  enqueue_kernel(ckNLMCalcDifference, w * h, num_shifts, true);
  enqueue_kernel(ckNLMBlur, w * h, num_shifts, true);
  enqueue_kernel(ckNLMCalcWeight, w * h, num_shifts, true);
  enqueue_kernel(ckNLMBlur, w * h, num_shifts, true);
  enqueue_kernel(ckNLMConstructGramian, w * h, num_shifts, true, 256);

  return true;
}

bool OpenCLDevice::denoising_solve(device_ptr output_ptr, DenoisingTask *task)
{
  cl_kernel ckFinalize = denoising_program(ustring(""filter_finalize""));

  cl_mem output_mem = CL_MEM_PTR(output_ptr);
  cl_mem rank_mem = CL_MEM_PTR(task->storage.rank.device_pointer);
  cl_mem XtWX_mem = CL_MEM_PTR(task->storage.XtWX.device_pointer);
  cl_mem XtWY_mem = CL_MEM_PTR(task->storage.XtWY.device_pointer);

  int w = task->reconstruction_state.source_w;
  int h = task->reconstruction_state.source_h;

  kernel_set_args(ckFinalize,
                  0,
                  output_mem,
                  rank_mem,
                  XtWX_mem,
                  XtWY_mem,
                  task->filter_area,
                  task->reconstruction_state.buffer_params,
                  task->render_buffer.samples);
  enqueue_kernel(ckFinalize, w, h);

  return true;
}

bool OpenCLDevice::denoising_combine_halves(device_ptr a_ptr,
                                            device_ptr b_ptr,
                                            device_ptr mean_ptr,
                                            device_ptr variance_ptr,
                                            int r,
                                            int4 rect,
                                            DenoisingTask *task)
{
  cl_mem a_mem = CL_MEM_PTR(a_ptr);
  cl_mem b_mem = CL_MEM_PTR(b_ptr);
  cl_mem mean_mem = CL_MEM_PTR(mean_ptr);
  cl_mem variance_mem = CL_MEM_PTR(variance_ptr);

  cl_kernel ckFilterCombineHalves = denoising_program(ustring(""filter_combine_halves""));

  kernel_set_args(ckFilterCombineHalves, 0, mean_mem, variance_mem, a_mem, b_mem, rect, r);
  enqueue_kernel(ckFilterCombineHalves, task->rect.z - task->rect.x, task->rect.w - task->rect.y);

  return true;
}

bool OpenCLDevice::denoising_divide_shadow(device_ptr a_ptr,
                                           device_ptr b_ptr,
                                           device_ptr sample_variance_ptr,
                                           device_ptr sv_variance_ptr,
                                           device_ptr buffer_variance_ptr,
                                           DenoisingTask *task)
{
  cl_mem a_mem = CL_MEM_PTR(a_ptr);
  cl_mem b_mem = CL_MEM_PTR(b_ptr);
  cl_mem sample_variance_mem = CL_MEM_PTR(sample_variance_ptr);
  cl_mem sv_variance_mem = CL_MEM_PTR(sv_variance_ptr);
  cl_mem buffer_variance_mem = CL_MEM_PTR(buffer_variance_ptr);

  cl_mem tile_info_mem = CL_MEM_PTR(task->tile_info_mem.device_pointer);

  cl_kernel ckFilterDivideShadow = denoising_program(ustring(""filter_divide_shadow""));

  int arg_ofs = kernel_set_args(
      ckFilterDivideShadow, 0, task->render_buffer.samples, tile_info_mem);
  cl_mem buffers[9];
  for (int i = 0; i < 9; i++) {
    buffers[i] = CL_MEM_PTR(task->tile_info->buffers[i]);
    arg_ofs += kernel_set_args(ckFilterDivideShadow, arg_ofs, buffers[i]);
  }
  kernel_set_args(ckFilterDivideShadow,
                  arg_ofs,
                  a_mem,
                  b_mem,
                  sample_variance_mem,
                  sv_variance_mem,
                  buffer_variance_mem,
                  task->rect,
                  task->render_buffer.pass_stride,
                  task->render_buffer.offset);
  enqueue_kernel(ckFilterDivideShadow, task->rect.z - task->rect.x, task->rect.w - task->rect.y);

  return true;
}

bool OpenCLDevice::denoising_get_feature(int mean_offset,
                                         int variance_offset,
                                         device_ptr mean_ptr,
                                         device_ptr variance_ptr,
                                         float scale,
                                         DenoisingTask *task)
{
  cl_mem mean_mem = CL_MEM_PTR(mean_ptr);
  cl_mem variance_mem = CL_MEM_PTR(variance_ptr);

  cl_mem tile_info_mem = CL_MEM_PTR(task->tile_info_mem.device_pointer);

  cl_kernel ckFilterGetFeature = denoising_program(ustring(""filter_get_feature""));

  int arg_ofs = kernel_set_args(ckFilterGetFeature, 0, task->render_buffer.samples, tile_info_mem);
  cl_mem buffers[9];
  for (int i = 0; i < 9; i++) {
    buffers[i] = CL_MEM_PTR(task->tile_info->buffers[i]);
    arg_ofs += kernel_set_args(ckFilterGetFeature, arg_ofs, buffers[i]);
  }
  kernel_set_args(ckFilterGetFeature,
                  arg_ofs,
                  mean_offset,
                  variance_offset,
                  mean_mem,
                  variance_mem,
                  scale,
                  task->rect,
                  task->render_buffer.pass_stride,
                  task->render_buffer.offset);
  enqueue_kernel(ckFilterGetFeature, task->rect.z - task->rect.x, task->rect.w - task->rect.y);

  return true;
}

bool OpenCLDevice::denoising_write_feature(int out_offset,
                                           device_ptr from_ptr,
                                           device_ptr buffer_ptr,
                                           DenoisingTask *task)
{
  cl_mem from_mem = CL_MEM_PTR(from_ptr);
  cl_mem buffer_mem = CL_MEM_PTR(buffer_ptr);

  cl_kernel ckFilterWriteFeature = denoising_program(ustring(""filter_write_feature""));

  kernel_set_args(ckFilterWriteFeature,
                  0,
                  task->render_buffer.samples,
                  task->reconstruction_state.buffer_params,
                  task->filter_area,
                  from_mem,
                  buffer_mem,
                  out_offset,
                  task->rect);
  enqueue_kernel(ckFilterWriteFeature, task->filter_area.z, task->filter_area.w);

  return true;
}

bool OpenCLDevice::denoising_detect_outliers(device_ptr image_ptr,
                                             device_ptr variance_ptr,
                                             device_ptr depth_ptr,
                                             device_ptr output_ptr,
                                             DenoisingTask *task)
{
  cl_mem image_mem = CL_MEM_PTR(image_ptr);
  cl_mem variance_mem = CL_MEM_PTR(variance_ptr);
  cl_mem depth_mem = CL_MEM_PTR(depth_ptr);
  cl_mem output_mem = CL_MEM_PTR(output_ptr);

  cl_kernel ckFilterDetectOutliers = denoising_program(ustring(""filter_detect_outliers""));

  kernel_set_args(ckFilterDetectOutliers,
                  0,
                  image_mem,
                  variance_mem,
                  depth_mem,
                  output_mem,
                  task->rect,
                  task->buffer.pass_stride);
  enqueue_kernel(ckFilterDetectOutliers, task->rect.z - task->rect.x, task->rect.w - task->rect.y);

  return true;
}

void OpenCLDevice::denoise(RenderTile &rtile, DenoisingTask &denoising)
{
  denoising.functions.construct_transform = function_bind(
      &OpenCLDevice::denoising_construct_transform, this, &denoising);
  denoising.functions.accumulate = function_bind(
      &OpenCLDevice::denoising_accumulate, this, _1, _2, _3, _4, &denoising);
  denoising.functions.solve = function_bind(&OpenCLDevice::denoising_solve, this, _1, &denoising);
  denoising.functions.divide_shadow = function_bind(
      &OpenCLDevice::denoising_divide_shadow, this, _1, _2, _3, _4, _5, &denoising);
  denoising.functions.non_local_means = function_bind(
      &OpenCLDevice::denoising_non_local_means, this, _1, _2, _3, _4, &denoising);
  denoising.functions.combine_halves = function_bind(
      &OpenCLDevice::denoising_combine_halves, this, _1, _2, _3, _4, _5, _6, &denoising);
  denoising.functions.get_feature = function_bind(
      &OpenCLDevice::denoising_get_feature, this, _1, _2, _3, _4, _5, &denoising);
  denoising.functions.write_feature = function_bind(
      &OpenCLDevice::denoising_write_feature, this, _1, _2, _3, &denoising);
  denoising.functions.detect_outliers = function_bind(
      &OpenCLDevice::denoising_detect_outliers, this, _1, _2, _3, _4, &denoising);

  denoising.filter_area = make_int4(rtile.x, rtile.y, rtile.w, rtile.h);
  denoising.render_buffer.samples = rtile.sample;
  denoising.buffer.gpu_temporary_mem = true;

  denoising.run_denoising(&rtile);
}

void OpenCLDevice::shader(DeviceTask &task)
{
  /* cast arguments to cl types */
  cl_mem d_data = CL_MEM_PTR(const_mem_map[""__data""]->device_pointer);
  cl_mem d_input = CL_MEM_PTR(task.shader_input);
  cl_mem d_output = CL_MEM_PTR(task.shader_output);
  cl_int d_shader_eval_type = task.shader_eval_type;
  cl_int d_shader_filter = task.shader_filter;
  cl_int d_shader_x = task.shader_x;
  cl_int d_shader_w = task.shader_w;
  cl_int d_offset = task.offset;

  OpenCLDevice::OpenCLProgram *program = &background_program;
  if (task.shader_eval_type >= SHADER_EVAL_BAKE) {
    program = &bake_program;
  }
  else if (task.shader_eval_type == SHADER_EVAL_DISPLACE) {
    program = &displace_program;
  }
  program->wait_for_availability();
  cl_kernel kernel = (*program)();

  cl_uint start_arg_index = kernel_set_args(kernel, 0, d_data, d_input, d_output);

  set_kernel_arg_buffers(kernel, &start_arg_index);

  start_arg_index += kernel_set_args(kernel, start_arg_index, d_shader_eval_type);
  if (task.shader_eval_type >= SHADER_EVAL_BAKE) {
    start_arg_index += kernel_set_args(kernel, start_arg_index, d_shader_filter);
  }
  start_arg_index += kernel_set_args(kernel, start_arg_index, d_shader_x, d_shader_w, d_offset);

  for (int sample = 0; sample < task.num_samples; sample++) {

    if (task.get_cancel())
      break;

    kernel_set_args(kernel, start_arg_index, sample);

    enqueue_kernel(kernel, task.shader_w, 1);

    clFinish(cqCommandQueue);

    task.update_progress(NULL);
  }
}

string OpenCLDevice::kernel_build_options(const string *debug_src)
{
  string build_options = ""-cl-no-signed-zeros -cl-mad-enable "";

  if (platform_name == ""NVIDIA CUDA"") {
    build_options +=
        ""-D__KERNEL_OPENCL_NVIDIA__ ""
        ""-cl-nv-maxrregcount=32 ""
        ""-cl-nv-verbose "";

    uint compute_capability_major, compute_capability_minor;
    clGetDeviceInfo(cdDevice,
                    CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV,
                    sizeof(cl_uint),
                    &compute_capability_major,
                    NULL);
    clGetDeviceInfo(cdDevice,
                    CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV,
                    sizeof(cl_uint),
                    &compute_capability_minor,
                    NULL);

    build_options += string_printf(""-D__COMPUTE_CAPABILITY__=%u "",
                                   compute_capability_major * 100 + compute_capability_minor * 10);
  }

  else if (platform_name == ""Apple"")
    build_options += ""-D__KERNEL_OPENCL_APPLE__ "";

  else if (platform_name == ""AMD Accelerated Parallel Processing"")
    build_options += ""-D__KERNEL_OPENCL_AMD__ "";

  else if (platform_name == ""Intel(R) OpenCL"") {
    build_options += ""-D__KERNEL_OPENCL_INTEL_CPU__ "";

    /* Options for gdb source level kernel debugging.
     * this segfaults on linux currently.
     */
    if (OpenCLInfo::use_debug() && debug_src)
      build_options += ""-g -s \\"""" + *debug_src + ""\\"" "";
  }

  if (info.has_half_images) {
    build_options += ""-D__KERNEL_CL_KHR_FP16__ "";
  }

  if (OpenCLInfo::use_debug()) {
    build_options += ""-D__KERNEL_OPENCL_DEBUG__ "";
  }

#  ifdef WITH_CYCLES_DEBUG
  build_options += ""-D__KERNEL_DEBUG__ "";
#  endif

  return build_options;
}

/* TODO(sergey): In the future we can use variadic templates, once
 * C++0x is allowed. Should allow to clean this up a bit.
 */
int OpenCLDevice::kernel_set_args(cl_kernel kernel,
                                  int start_argument_index,
                                  const ArgumentWrapper &arg1,
                                  const ArgumentWrapper &arg2,
                                  const ArgumentWrapper &arg3,
                                  const ArgumentWrapper &arg4,
                                  const ArgumentWrapper &arg5,
                                  const ArgumentWrapper &arg6,
                                  const ArgumentWrapper &arg7,
                                  const ArgumentWrapper &arg8,
                                  const ArgumentWrapper &arg9,
                                  const ArgumentWrapper &arg10,
                                  const ArgumentWrapper &arg11,
                                  const ArgumentWrapper &arg12,
                                  const ArgumentWrapper &arg13,
                                  const ArgumentWrapper &arg14,
                                  const ArgumentWrapper &arg15,
                                  const ArgumentWrapper &arg16,
                                  const ArgumentWrapper &arg17,
                                  const ArgumentWrapper &arg18,
                                  const ArgumentWrapper &arg19,
                                  const ArgumentWrapper &arg20,
                                  const ArgumentWrapper &arg21,
                                  const ArgumentWrapper &arg22,
                                  const ArgumentWrapper &arg23,
                                  const ArgumentWrapper &arg24,
                                  const ArgumentWrapper &arg25,
                                  const ArgumentWrapper &arg26,
                                  const ArgumentWrapper &arg27,
                                  const ArgumentWrapper &arg28,
                                  const ArgumentWrapper &arg29,
                                  const ArgumentWrapper &arg30,
                                  const ArgumentWrapper &arg31,
                                  const ArgumentWrapper &arg32,
                                  const ArgumentWrapper &arg33)
{
  int current_arg_index = 0;
#  define FAKE_VARARG_HANDLE_ARG(arg) \\
    do { \\
      if (arg.pointer != NULL) { \\
        opencl_assert(clSetKernelArg( \\
            kernel, start_argument_index + current_arg_index, arg.size, arg.pointer)); \\
        ++current_arg_index; \\
      } \\
      else { \\
        return current_arg_index; \\
      } \\
    } while (false)
  FAKE_VARARG_HANDLE_ARG(arg1);
  FAKE_VARARG_HANDLE_ARG(arg2);
  FAKE_VARARG_HANDLE_ARG(arg3);
  FAKE_VARARG_HANDLE_ARG(arg4);
  FAKE_VARARG_HANDLE_ARG(arg5);
  FAKE_VARARG_HANDLE_ARG(arg6);
  FAKE_VARARG_HANDLE_ARG(arg7);
  FAKE_VARARG_HANDLE_ARG(arg8);
  FAKE_VARARG_HANDLE_ARG(arg9);
  FAKE_VARARG_HANDLE_ARG(arg10);
  FAKE_VARARG_HANDLE_ARG(arg11);
  FAKE_VARARG_HANDLE_ARG(arg12);
  FAKE_VARARG_HANDLE_ARG(arg13);
  FAKE_VARARG_HANDLE_ARG(arg14);
  FAKE_VARARG_HANDLE_ARG(arg15);
  FAKE_VARARG_HANDLE_ARG(arg16);
  FAKE_VARARG_HANDLE_ARG(arg17);
  FAKE_VARARG_HANDLE_ARG(arg18);
  FAKE_VARARG_HANDLE_ARG(arg19);
  FAKE_VARARG_HANDLE_ARG(arg20);
  FAKE_VARARG_HANDLE_ARG(arg21);
  FAKE_VARARG_HANDLE_ARG(arg22);
  FAKE_VARARG_HANDLE_ARG(arg23);
  FAKE_VARARG_HANDLE_ARG(arg24);
  FAKE_VARARG_HANDLE_ARG(arg25);
  FAKE_VARARG_HANDLE_ARG(arg26);
  FAKE_VARARG_HANDLE_ARG(arg27);
  FAKE_VARARG_HANDLE_ARG(arg28);
  FAKE_VARARG_HANDLE_ARG(arg29);
  FAKE_VARARG_HANDLE_ARG(arg30);
  FAKE_VARARG_HANDLE_ARG(arg31);
  FAKE_VARARG_HANDLE_ARG(arg32);
  FAKE_VARARG_HANDLE_ARG(arg33);
#  undef FAKE_VARARG_HANDLE_ARG
  return current_arg_index;
}

void OpenCLDevice::release_kernel_safe(cl_kernel kernel)
{
  if (kernel) {
    clReleaseKernel(kernel);
  }
}

void OpenCLDevice::release_mem_object_safe(cl_mem mem)
{
  if (mem != NULL) {
    clReleaseMemObject(mem);
  }
}

void OpenCLDevice::release_program_safe(cl_program program)
{
  if (program) {
    clReleaseProgram(program);
  }
}

/* ** Those guys are for workign around some compiler-specific bugs ** */

cl_program OpenCLDevice::load_cached_kernel(ustring key, thread_scoped_lock &cache_locker)
{
  return OpenCLCache::get_program(cpPlatform, cdDevice, key, cache_locker);
}

void OpenCLDevice::store_cached_kernel(cl_program program,
                                       ustring key,
                                       thread_scoped_lock &cache_locker)
{
  OpenCLCache::store_program(cpPlatform, cdDevice, program, key, cache_locker);
}

Device *opencl_create_split_device(DeviceInfo &info,
                                   Stats &stats,
                                   Profiler &profiler,
                                   bool background)
{
  return new OpenCLDevice(info, stats, profiler, background);
}

CCL_NAMESPACE_END

#endif
",16128,True,2628.190599215351,median
":spring-data-commons-ref: https://docs.spring.io/spring-data/data-commons/docs/current/reference/html

== Spring Data Cloud Spanner

https://projects.spring.io/spring-data/[Spring Data] is an abstraction for storing and retrieving POJOs in numerous storage technologies.
Spring Cloud GCP adds Spring Data support for https://cloud.google.com/spanner/[Google Cloud Spanner].

Maven coordinates for this module only, using <<getting-started.adoc#_bill_of_materials, Spring Cloud GCP BOM>>:

[source,xml]
----
<dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>spring-cloud-gcp-data-spanner</artifactId>
</dependency>
----

Gradle coordinates:

[source]
----
dependencies {
    implementation(""com.google.cloud:spring-cloud-gcp-data-spanner"")
}
----

We provide a link:../spring-cloud-gcp-starters/spring-cloud-gcp-starter-data-spanner[Spring Boot Starter for Spring Data Spanner], with which you can leverage our recommended auto-configuration setup.
To use the starter, see the coordinates see below.


Maven:

[source,xml]
----
<dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>spring-cloud-gcp-starter-data-spanner</artifactId>
</dependency>
----

Gradle:

[source,subs=""normal""]
----
dependencies {
    implementation(""com.google.cloud:spring-cloud-gcp-starter-data-spanner"")
}
----

This setup takes care of bringing in the latest compatible version of Cloud Java Cloud Spanner libraries as well.

=== Configuration

To setup Spring Data Cloud Spanner, you have to configure the following:

* Setup the connection details to Google Cloud Spanner.
* Enable Spring Data Repositories (optional).

==== Cloud Spanner settings

You can use the Spring Boot Starter for Spring Data Spanner to autoconfigure Google Cloud Spanner in your Spring application.
It contains all the necessary setup that makes it easy to authenticate with your Google Cloud project.
The following configuration options are available:

|===
| Name | Description | Required | Default value
| `spring.cloud.gcp.spanner.instance-id` | Cloud Spanner instance to use | Yes |
| `spring.cloud.gcp.spanner.database` |
Cloud Spanner database to use | Yes |
| `spring.cloud.gcp.spanner.project-id` | GCP project ID where the Google Cloud Spanner API is hosted, if different from the one in the <<spring-cloud-gcp-core,Spring Cloud GCP Core Module>>
| No |
| `spring.cloud.gcp.spanner.credentials.location` | OAuth2 credentials for authenticating with the
Google Cloud Spanner API, if different from the ones in the
<<spring-cloud-gcp-core,Spring Cloud GCP Core Module>> | No |
| `spring.cloud.gcp.spanner.credentials.encoded-key` | Base64-encoded OAuth2 credentials for authenticating with the
Google Cloud Spanner API, if different from the ones in the
<<spring-cloud-gcp-core,Spring Cloud GCP Core Module>> | No |
| `spring.cloud.gcp.spanner.credentials.scopes` |
https://developers.google.com/identity/protocols/googlescopes[OAuth2 scope] for Spring Cloud GCP
Cloud Spanner credentials | No | https://www.googleapis.com/auth/spanner.data
| `spring.cloud.gcp.spanner.createInterleavedTableDdlOnDeleteCascade` | If `true`, then schema statements generated by `SpannerSchemaUtils` for tables with interleaved parent-child relationships will be ""ON DELETE CASCADE"".
The schema for the tables will be ""ON DELETE NO ACTION"" if `false`. | No | `true`
| `spring.cloud.gcp.spanner.numRpcChannels` | Number of gRPC channels used to connect to Cloud Spanner | No | 4 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.prefetchChunks` | Number of chunks prefetched by Cloud Spanner for read and query | No | 4 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.minSessions` | Minimum number of sessions maintained in the session pool | No | 0 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.maxSessions` | Maximum number of sessions session pool can have | No | 400 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.maxIdleSessions` | Maximum number of idle sessions session pool will maintain | No | 0 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.writeSessionsFraction` | Fraction of sessions to be kept prepared for write transactions | No | 0.2 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.keepAliveIntervalMinutes` | How long to keep idle sessions alive | No | 30 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.failIfPoolExhausted` |  If all sessions are in use, fail the request by throwing an exception. Otherwise, by default, block until a session becomes available. | No | `false`
| `spring.cloud.gcp.spanner.emulator.enabled` |  Enables the usage of an emulator. If this is set to true, then you should set the `spring.cloud.gcp.spanner.emulator-host` to the host:port of your locally running emulator instance. | No | `false`
| `spring.cloud.gcp.spanner.emulator-host` |  The host and port of the Spanner emulator; can be overridden to specify connecting to an already-running https://cloud.google.com/spanner/docs/emulator#installing_and_running_the_emulator[Spanner emulator] instance. | No | `localhost:9010`
|===

NOTE: For further customization of the client library `SpannerOptions`, provide a bean implementing `SpannerOptionsCustomizer`, with a single method that accepts a `SpannerOptions.Builder` and modifies it as necessary.

==== Repository settings

Spring Data Repositories can be configured via the `@EnableSpannerRepositories` annotation on your main `@Configuration` class.
With our Spring Boot Starter for Spring Data Cloud Spanner, `@EnableSpannerRepositories` is automatically added.
It is not required to add it to any other class, unless there is a need to override finer grain configuration parameters provided by https://github.com/GoogleCloudPlatform/spring-cloud-gcp/blob/main/spring-cloud-gcp-data-spanner/src/main/java/com/google/cloud/spring/data/spanner/repository/config/EnableSpannerRepositories.java[`@EnableSpannerRepositories`].

==== Autoconfiguration

Our Spring Boot autoconfiguration creates the following beans available in the Spring application context:

- an instance of `SpannerTemplate`
- an instance of `SpannerDatabaseAdminTemplate` for generating table schemas from object hierarchies and creating and deleting tables and databases
- an instance of all user-defined repositories extending `SpannerRepository`, `CrudRepository`, `PagingAndSortingRepository`, when repositories are enabled
- an instance of `DatabaseClient` from the Google Cloud Java Client for Spanner, for convenience and lower level API access


=== Object Mapping

Spring Data Cloud Spanner allows you to map domain POJOs to Cloud Spanner tables via annotations:

[source,java]
----
@Table(name = ""traders"")
public class Trader {

	@PrimaryKey
	@Column(name = ""trader_id"")
	String traderId;

	String firstName;

	String lastName;

	@NotMapped
	Double temporaryNumber;
}
----

Spring Data Cloud Spanner will ignore any property annotated with `@NotMapped`.
These properties will not be written to or read from Spanner.

==== Constructors

Simple constructors are supported on POJOs.
The constructor arguments can be a subset of the persistent properties.
Every constructor argument needs to have the same name and type as a persistent property on the entity and the constructor should set the property from the given argument.
Arguments that are not directly set to properties are not supported.

[source,java]
----
@Table(name = ""traders"")
public class Trader {
	@PrimaryKey
	@Column(name = ""trader_id"")
	String traderId;

	String firstName;

	String lastName;

	@NotMapped
	Double temporaryNumber;

	public Trader(String traderId, String firstName) {
	    this.traderId = traderId;
	    this.firstName = firstName;
	}
}
----


==== Table

The `@Table` annotation can provide the name of the Cloud Spanner table that stores instances of the annotated class, one per row.
This annotation is optional, and if not given, the name of the table is inferred from the class name with the first character uncapitalized.

===== SpEL expressions for table names

In some cases, you might want the `@Table` table name to be determined dynamically.
To do that, you can use https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#expressions[Spring Expression Language].

For example:

[source, java]
----

@Table(name = ""trades_#{tableNameSuffix}"")
public class Trade {
	// ...
}
----

The table name will be resolved only if the `tableNameSuffix` value/bean in the Spring application context is defined.
For example, if `tableNameSuffix` has the value ""123"", the table name will resolve to `trades_123`.

==== Primary Keys

For a simple table, you may only have a primary key consisting of a single column.
Even in that case, the `@PrimaryKey` annotation is required.
`@PrimaryKey` identifies the one or more ID properties corresponding to the primary key.

Spanner has first class support for composite primary keys of multiple columns.
You have to annotate all of your POJO's fields that the primary key consists of with `@PrimaryKey` as below:

[source,java]
----
@Table(name = ""trades"")
public class Trade {
	@PrimaryKey(keyOrder = 2)
	@Column(name = ""trade_id"")
	private String tradeId;

	@PrimaryKey(keyOrder = 1)
	@Column(name = ""trader_id"")
	private String traderId;

	private String action;

	private BigDecimal price;

	private Double shares;

	private String symbol;
}
----

The `keyOrder` parameter of `@PrimaryKey` identifies the properties corresponding to the primary key columns in order, starting with 1 and increasing consecutively.
Order is important and must reflect the order defined in the Cloud Spanner schema.
In our example the DDL to create the table and its primary key is as follows:

[source,sql]
----
CREATE TABLE trades (
    trader_id STRING(MAX),
    trade_id STRING(MAX),
    action STRING(15),
    symbol STRING(10),
    price NUMERIC,
    shares FLOAT64
) PRIMARY KEY (trader_id, trade_id)
----

Spanner does not have automatic ID generation.
For most use-cases, sequential IDs should be used with caution to avoid creating data hotspots in the system.
Read https://cloud.google.com/spanner/docs/schema-and-data-model#primary_keys[Spanner Primary Keys documentation] for a better understanding of primary keys and recommended practices.


==== Columns

All accessible properties on POJOs are automatically recognized as a Cloud Spanner column.
Column naming is generated by the `PropertyNameFieldNamingStrategy` by default defined on the `SpannerMappingContext` bean.
The `@Column` annotation optionally provides a different column name than that of the property and some other settings:

- `name` is the optional name of the column
- `spannerTypeMaxLength` specifies for `STRING` and `BYTES` columns the maximum length.
This setting is only used when generating DDL schema statements based on domain types.
- `nullable` specifies if the column is created as `NOT NULL`.
This setting is only used when generating DDL schema statements based on domain types.
- `spannerType` is the Cloud Spanner column type you can optionally specify.
If this is not specified then a compatible column type is inferred from the Java property type.
- `spannerCommitTimestamp` is a boolean specifying if this property corresponds to an auto-populated commit timestamp column.
Any value set in this property will be ignored when writing to Cloud Spanner.


==== Embedded Objects

If an object of type `B` is embedded as a property of `A`, then the columns of `B` will be saved in the same Cloud Spanner table as those of `A`.

If `B` has primary key columns, those columns will be included in the primary key of `A`. `B` can also have embedded properties.
Embedding allows reuse of columns between multiple entities, and can be useful for implementing parent-child situations, because Cloud Spanner requires child tables to include the key columns of their parents.

For example:

[source,java]
----
class X {
  @PrimaryKey
  String grandParentId;

  long age;
}

class A {
  @PrimaryKey
  @Embedded
  X grandParent;

  @PrimaryKey(keyOrder = 2)
  String parentId;

  String value;
}

@Table(name = ""items"")
class B {
  @PrimaryKey
  @Embedded
  A parent;

  @PrimaryKey(keyOrder = 2)
  String id;

  @Column(name = ""child_value"")
  String value;
}
----

Entities of `B` can be stored in a table defined as:

[source,sql]
----
CREATE TABLE items (
    grandParentId STRING(MAX),
    parentId STRING(MAX),
    id STRING(MAX),
    value STRING(MAX),
    child_value STRING(MAX),
    age INT64
) PRIMARY KEY (grandParentId, parentId, id)
----

Note that embedded properties' column names must all be unique.


==== Relationships

Spring Data Cloud Spanner supports parent-child relationships using the Cloud Spanner https://cloud.google.com/spanner/docs/schema-and-data-model#creating-interleaved-tables[parent-child interleaved table mechanism].
Cloud Spanner interleaved tables enforce the one-to-many relationship and provide efficient queries and operations on entities of a single domain parent entity.
These relationships can be up to 7 levels deep.
Cloud Spanner also provides automatic cascading delete or enforces the deletion of child entities before parents.

While one-to-one and many-to-many relationships can be implemented in Cloud Spanner and Spring Data Cloud Spanner using constructs of interleaved parent-child tables, only the parent-child relationship is natively supported.
Cloud Spanner does not support the foreign key constraint, though the parent-child key constraint enforces a similar requirement when used with interleaved tables.

For example, the following Java entities:

[source,java]
----
@Table(name = ""Singers"")
class Singer {
  @PrimaryKey
  long SingerId;

  String FirstName;

  String LastName;

  byte[] SingerInfo;

  @Interleaved
  List<Album> albums;
}

@Table(name = ""Albums"")
class Album {
  @PrimaryKey
  long SingerId;

  @PrimaryKey(keyOrder = 2)
  long AlbumId;

  String AlbumTitle;
}
----

These classes can correspond to an existing pair of interleaved tables.
The `@Interleaved` annotation may be applied to `Collection` properties and the inner type is resolved as the child entity type.
The schema needed to create them can also be generated using the `SpannerSchemaUtils` and run by using the `SpannerDatabaseAdminTemplate`:

[source,java]
----

@Autowired
SpannerSchemaUtils schemaUtils;

@Autowired
SpannerDatabaseAdminTemplate databaseAdmin;
...

// Get the create statmenets for all tables in the table structure rooted at Singer
List<String> createStrings = this.schemaUtils.getCreateTableDdlStringsForInterleavedHierarchy(Singer.class);

// Create the tables and also create the database if necessary
this.databaseAdmin.executeDdlStrings(createStrings, true);
----

The `createStrings` list contains table schema statements using column names and types compatible with the provided Java type and any resolved child relationship types contained within based on the configured custom converters.

[source,sql]
----
CREATE TABLE Singers (
  SingerId   INT64 NOT NULL,
  FirstName  STRING(1024),
  LastName   STRING(1024),
  SingerInfo BYTES(MAX),
) PRIMARY KEY (SingerId);

CREATE TABLE Albums (
  SingerId     INT64 NOT NULL,
  AlbumId      INT64 NOT NULL,
  AlbumTitle   STRING(MAX),
) PRIMARY KEY (SingerId, AlbumId),
  INTERLEAVE IN PARENT Singers ON DELETE CASCADE;
----

The `ON DELETE CASCADE` clause indicates that Cloud Spanner will delete all Albums of a singer if the Singer is deleted.
The alternative is `ON DELETE NO ACTION`, where a Singer cannot be deleted until all of its Albums have already been deleted.
When using `SpannerSchemaUtils` to generate the schema strings, the `spring.cloud.gcp.spanner.createInterleavedTableDdlOnDeleteCascade` boolean setting determines if these schema are generated as `ON DELETE CASCADE` for `true` and `ON DELETE NO ACTION` for `false`.

Cloud Spanner restricts these relationships to 7 child layers.
A table may have multiple child tables.

On updating or inserting an object to Cloud Spanner, all of its referenced children objects are also updated or inserted in the same request, respectively.
On read, all of the interleaved child rows are also all read.

===== Lazy Fetch

`@Interleaved` properties are retrieved eagerly by default, but can be fetched lazily for performance in both read and write:

[source,java]
----
@Interleaved(lazy = true)
List<Album> albums;
----

Lazily-fetched interleaved properties are retrieved upon the first interaction with the property.
If a property marked for lazy fetching is never retrieved, then it is also skipped when saving the parent entity.

If used inside a transaction, subsequent operations on lazily-fetched properties use the same transaction context as that of the original parent entity.

===== Declarative Filtering with `@Where`
The `@Where` annotation could be applied to an entity class or to an interleaved property.
This annotation provides an SQL where clause that will be applied at the fetching of interleaved collections or the entity itself.

Let's say we have an `Agreement` with a list of `Participants` which could be assigned to it.
We would like to fetch a list of currently active participants.
For security reasons, all records should remain in the database forever, even if participants become inactive.
That can be easily achieved with the `@Where` annotation, which is demonstrated by this example:

[source, java]
----
@Table(name = ""participants"")
public class Participant {
  //...
  boolean active;
  //...
}

@Table(name = ""agreements"")
public class Agreement {
  //...
  @Interleaved
  @Where(""active = true"")
  List<Participant> participants;
  Person person;
  //...
}
----

==== Supported Types

Spring Data Cloud Spanner natively supports the following types for regular fields but also utilizes custom converters (detailed in following sections) and dozens of pre-defined Spring Data custom converters to handle other common Java types.

Natively supported types:

* `com.google.cloud.ByteArray`
* `com.google.cloud.Date`
* `com.google.cloud.Timestamp`
* `java.lang.Boolean`, `boolean`
* `java.lang.Double`, `double`
* `java.lang.Long`, `long`
* `java.lang.Integer`, `int`
* `java.lang.String`
* `double[]`
* `long[]`
* `boolean[]`
* `java.util.Date`
* `java.time.Instant`
* `java.sql.Date`
* `java.time.LocalDate`
* `java.time.LocalDateTime`


==== Lists

Spanner supports `ARRAY` types for columns.
`ARRAY` columns are mapped to `List` fields in POJOS.

Example:

[source,java]
----
List<Double> curve;
----

The types inside the lists can be any singular property type.

==== Lists of Structs

Cloud Spanner queries can https://cloud.google.com/spanner/docs/query-syntax#using-structs-with-select[construct STRUCT values] that appear as columns in the result.
Cloud Spanner requires STRUCT values appear in ARRAYs at the root level: `SELECT ARRAY(SELECT STRUCT(1 as val1, 2 as val2)) as pair FROM Users`.

Spring Data Cloud Spanner will attempt to read the column STRUCT values into a property that is an `Iterable` of an entity type compatible with the schema of the column STRUCT value.


For the previous array-select example, the following property can be mapped with the constructed `ARRAY<STRUCT>` column: `List<TwoInts> pair;` where the `TwoInts` type is defined:

[source, java]
----
class TwoInts {

  int val1;

  int val2;
}
----

==== Custom types

Custom converters can be used to extend the type support for user defined types.

. Converters need to implement the `org.springframework.core.convert.converter.Converter` interface in both directions.
. The user defined type needs to be mapped to one of the basic types supported by Spanner:

* `com.google.cloud.ByteArray`
* `com.google.cloud.Date`
* `com.google.cloud.Timestamp`
* `java.lang.Boolean`, `boolean`
* `java.lang.Double`, `double`
* `java.lang.Long`, `long`
* `java.lang.String`
* `double[]`
* `long[]`
* `boolean[]`
* `enum` types

. An instance of both Converters needs to be passed to a `ConverterAwareMappingSpannerEntityProcessor`, which then has to be made available as a `@Bean` for `SpannerEntityProcessor`.

For example:

We would like to have a field of type `Person` on our `Trade` POJO:
[source, java]
----

@Table(name = ""trades"")
public class Trade {
  //...
  Person person;
  //...
}
----

Where Person is a simple class:

[source, java]
----
public class Person {

  public String firstName;
  public String lastName;

}
----

We have to define the two converters:

[source, java]
----
  public class PersonWriteConverter implements Converter<Person, String> {

    @Override
    public String convert(Person person) {
      return person.firstName + "" "" + person.lastName;
    }
  }

  public class PersonReadConverter implements Converter<String, Person> {

    @Override
    public Person convert(String s) {
      Person person = new Person();
      person.firstName = s.split("" "")[0];
      person.lastName = s.split("" "")[1];
      return person;
    }
  }
----

That will be configured in our `@Configuration` file:

[source, java]
----
@Configuration
public class ConverterConfiguration {

	@Bean
	public SpannerEntityProcessor spannerEntityProcessor(SpannerMappingContext spannerMappingContext) {
		return new ConverterAwareMappingSpannerEntityProcessor(spannerMappingContext,
				Arrays.asList(new PersonWriteConverter()),
				Arrays.asList(new PersonReadConverter()));
	}
}
----

==== Custom Converter for Struct Array Columns
If a `Converter<Struct, A>` is provided, then properties of type `List<A>` can be used in your entity types.


=== Spanner Operations & Template

`SpannerOperations` and its implementation, `SpannerTemplate`, provides the Template pattern familiar to Spring developers.
It provides:

 - Resource management
 - One-stop-shop to Spanner operations with the Spring Data POJO mapping and conversion features
 - Exception conversion

Using the `autoconfigure` provided by our Spring Boot Starter for Spanner, your Spring application context will contain a fully configured `SpannerTemplate` object that you can easily autowire in your application:

[source,java]
----
@SpringBootApplication
public class SpannerTemplateExample {

	@Autowired
	SpannerTemplate spannerTemplate;

	public void doSomething() {
		this.spannerTemplate.delete(Trade.class, KeySet.all());
		//...
		Trade t = new Trade();
		//...
		this.spannerTemplate.insert(t);
		//...
		List<Trade> tradesByAction = spannerTemplate.findAll(Trade.class);
		//...
	}
}
----

The Template API provides convenience methods for:

- https://cloud.google.com/spanner/docs/reads[Reads], and by providing SpannerReadOptions and
SpannerQueryOptions
   ** Stale read
   ** Read with secondary indices
   ** Read with limits and offsets
   ** Read with sorting
- https://cloud.google.com/spanner/docs/reads#execute_a_query[Queries]
- DML operations (delete, insert, update, upsert)
- Partial reads
   ** You can define a set of columns to be read into your entity
- Partial writes
   ** Persist only a few properties from your entity
- Read-only transactions
- Locking read-write transactions

==== SQL Query

Cloud Spanner has SQL support for running read-only queries.
All the query related methods start with `query` on `SpannerTemplate`.
By using `SpannerTemplate`, you can run SQL queries that map to POJOs:

[source,java]
----
List<Trade> trades = this.spannerTemplate.query(Trade.class, Statement.of(""SELECT * FROM trades""));
----

==== Read

Spanner exposes a https://cloud.google.com/spanner/docs/reads[Read API] for reading single row or multiple rows in a table or in a secondary index.

Using `SpannerTemplate` you can run reads, as the following example shows:

[source,java]
----
List<Trade> trades = this.spannerTemplate.readAll(Trade.class);
----

Main benefit of reads over queries is reading multiple rows of a certain pattern of keys is much easier using the features of the https://github.com/GoogleCloudPlatform/google-cloud-java/blob/main/google-cloud-spanner/src/main/java/com/google/cloud/spanner/KeySet.java[`KeySet`] class.


==== Advanced reads

===== Stale read

All reads and queries are *strong reads* by default.
A *strong read* is a read at a current time and is guaranteed to see all data that has been committed up until the start of this read.
An *exact staleness read* is read at a timestamp in the past.
Cloud Spanner allows you to determine how current the data should be when you read data.
With `SpannerTemplate` you can specify the `Timestamp` by setting it on `SpannerQueryOptions` or `SpannerReadOptions` to the appropriate read or query methods:

Reads:

[source,java]
----
// a read with options:
SpannerReadOptions spannerReadOptions = new SpannerReadOptions().setTimestamp(myTimestamp);
List<Trade> trades = this.spannerTemplate.readAll(Trade.class, spannerReadOptions);
----

Queries:

[source,java]
----
// a query with options:
SpannerQueryOptions spannerQueryOptions = new SpannerQueryOptions().setTimestamp(myTimestamp);
List<Trade> trades = this.spannerTemplate.query(Trade.class, Statement.of(""SELECT * FROM trades""), spannerQueryOptions);
----

You can also read with https://cloud.google.com/spanner/docs/timestamp-bounds[*bounded staleness*] by setting `.setTimestampBound(TimestampBound.ofMinReadTimestamp(myTimestamp))` on the query and read options objects.
Bounded staleness lets Cloud Spanner choose any point in time later than or equal to the given timestampBound, but it cannot be used inside transactions.


===== Read from a secondary index

Using a https://cloud.google.com/spanner/docs/secondary-indexes[secondary index] is available for Reads via the Template API and it is also implicitly available via SQL for Queries.

The following shows how to read rows from a table using a https://cloud.google.com/spanner/docs/secondary-indexes[secondary index] simply by setting `index` on `SpannerReadOptions`:

[source,java]
----
SpannerReadOptions spannerReadOptions = new SpannerReadOptions().setIndex(""TradesByTrader"");
List<Trade> trades = this.spannerTemplate.readAll(Trade.class, spannerReadOptions);
----


===== Read with offsets and limits

Limits and offsets are only supported by Queries.
The following will get only the first two rows of the query:

[source,java]
----
SpannerQueryOptions spannerQueryOptions = new SpannerQueryOptions().setLimit(2).setOffset(3);
List<Trade> trades = this.spannerTemplate.query(Trade.class, Statement.of(""SELECT * FROM trades""), spannerQueryOptions);
----

Note that the above is equivalent of running `SELECT * FROM trades LIMIT 2 OFFSET 3`.

===== Sorting

Reads by keys do not support sorting.
However, queries on the Template API support sorting through standard SQL and also via Spring Data Sort API:

[source,java]
----
List<Trade> trades = this.spannerTemplate.queryAll(Trade.class, Sort.by(""action""));
----

If the provided sorted field name is that of a property of the domain type, then the column name corresponding to that property will be used in the query.
Otherwise, the given field name is assumed to be the name of the column in the Cloud Spanner table.
Sorting on columns of Cloud Spanner types STRING and BYTES can be done while ignoring case:

[source,java]
----
Sort.by(Order.desc(""action"").ignoreCase())
----

===== Partial read

Partial read is only possible when using Queries.
In case the rows returned by the query have fewer columns than the entity that it will be mapped to, Spring Data will map the returned columns only.
This setting also applies to nested structs and their corresponding nested POJO properties.

[source,java]
----
List<Trade> trades = this.spannerTemplate.query(Trade.class, Statement.of(""SELECT action, symbol FROM trades""),
    new SpannerQueryOptions().setAllowMissingResultSetColumns(true));
----

If the setting is set to `false`, then an exception will be thrown if there are missing columns in the query result.

===== Summary of options for Query vs Read

|===
| Feature | Query supports it | Read supports it
| SQL  | yes | no
| Partial read | yes | no
| Limits | yes | no
| Offsets | yes | no
| Secondary index | yes | yes
| Read using index range | no | yes
| Sorting | yes | no
|===

==== Write / Update

The write methods of `SpannerOperations` accept a POJO and writes all of its properties to Spanner.
The corresponding Spanner table and entity metadata is obtained from the given object's actual type.

If a POJO was retrieved from Spanner and its primary key properties values were changed and then written or updated, the operation will occur as if against a row with the new primary key values.
The row with the original primary key values will not be affected.

===== Insert

The `insert` method of `SpannerOperations` accepts a POJO and writes all of its properties to Spanner, which means the operation will fail if a row with the POJO's primary key already exists in the table.

[source, java]
----
Trade t = new Trade();
this.spannerTemplate.insert(t);
----

===== Update

The `update` method of `SpannerOperations` accepts a POJO and writes all of its properties to Spanner, which means the operation will fail if the POJO's primary key does not already exist in the table.

[source, java]
----
// t was retrieved from a previous operation
this.spannerTemplate.update(t);
----

===== Upsert

The `upsert` method of `SpannerOperations` accepts a POJO and writes all of its properties to Spanner using update-or-insert.

[source, java]
----
// t was retrieved from a previous operation or it's new
this.spannerTemplate.upsert(t);
----

===== Partial Update

The update methods of `SpannerOperations` operate by default on all properties within the given object, but also accept `String[]` and `Optional<Set<String>>` of column names.
If the `Optional` of set of column names is empty, then all columns are written to Spanner.
However, if the Optional is occupied by an empty set, then no columns will be written.


[source, java]
----
// t was retrieved from a previous operation or it's new
this.spannerTemplate.update(t, ""symbol"", ""action"");
----

==== DML

DML statements can be run by using `SpannerOperations.executeDmlStatement`.
Inserts, updates, and deletions can affect any number of rows and entities.

You can run https://cloud.google.com/spanner/docs/dml-partitioned[partitioned DML] updates by using the `executePartitionedDmlStatement` method.
Partitioned DML queries have performance benefits but also have restrictions and cannot be used inside transactions.

==== Transactions

`SpannerOperations` provides methods to run `java.util.Function` objects within a single transaction while making available the read and write methods from `SpannerOperations`.

===== Read/Write Transaction

Read and write transactions are provided by `SpannerOperations` via the `performReadWriteTransaction` method:

[source,java]
----

@Autowired
SpannerOperations mySpannerOperations;

public String doWorkInsideTransaction() {
  return mySpannerOperations.performReadWriteTransaction(
    transActionSpannerOperations -> {
      // Work with transActionSpannerOperations here.
      // It is also a SpannerOperations object.

      return ""transaction completed"";
    }
  );
}
----

The `performReadWriteTransaction` method accepts a `Function` that is provided an instance of a `SpannerOperations` object.
The final returned value and type of the function is determined by the user.
You can use this object just as you would a regular `SpannerOperations` with a few exceptions:

- Its read functionality cannot perform stale reads, because all reads and writes happen at the single point in time of the transaction.
- It cannot perform sub-transactions via `performReadWriteTransaction` or `performReadOnlyTransaction`.

As these read-write transactions are locking, it is recommended that you use the `performReadOnlyTransaction` if your function does not perform any writes.

===== Read-only Transaction

The `performReadOnlyTransaction` method is used to perform read-only transactions using a `SpannerOperations`:

[source,java]
----

@Autowired
SpannerOperations mySpannerOperations;

public String doWorkInsideTransaction() {
  return mySpannerOperations.performReadOnlyTransaction(
    transActionSpannerOperations -> {
      // Work with transActionSpannerOperations here.
      // It is also a SpannerOperations object.

      return ""transaction completed"";
    }
  );
}
----

The `performReadOnlyTransaction` method accepts a `Function` that is provided an instance of a
`SpannerOperations` object.
This method also accepts a `ReadOptions` object, but the only attribute used is the timestamp used to determine the snapshot in time to perform the reads in the transaction.
If the timestamp is not set in the read options the transaction is run against the current state of the database.
The final returned value and type of the function is determined by the user.
You can use this object just as you would a regular `SpannerOperations` with
a few exceptions:

- Its read functionality cannot perform stale reads (other than the staleness set on the entire transaction), because all reads happen at the single point in time of the transaction.
- It cannot perform sub-transactions via `performReadWriteTransaction` or `performReadOnlyTransaction`
- It cannot perform any write operations.

Because read-only transactions are non-locking and can be performed on points in time in the past, these are recommended for functions that do not perform write operations.

===== Declarative Transactions with @Transactional Annotation

This feature requires a bean of `SpannerTransactionManager`, which is provided when using `spring-cloud-gcp-starter-data-spanner`.

`SpannerTemplate` and `SpannerRepository` support running methods with the `@Transactional` https://docs.spring.io/spring/docs/current/spring-framework-reference/data-access.html#transaction-declarative[annotation] as transactions.
If a method annotated with `@Transactional` calls another method also annotated, then both methods will work within the same transaction.
`performReadOnlyTransaction` and `performReadWriteTransaction` cannot be used in `@Transactional` annotated methods because Cloud Spanner does not support transactions within transactions.

==== DML Statements

`SpannerTemplate` supports https://cloud.google.com/spanner/docs/dml-tasks:[DML] `Statements`.
DML statements can also be run in transactions by using `performReadWriteTransaction` or by using the `@Transactional` annotation.

=== Repositories

{spring-data-commons-ref}/#repositories[Spring Data Repositories] are a powerful abstraction that can save you a lot of boilerplate code.

For example:

[source,java]
----
public interface TraderRepository extends SpannerRepository<Trader, String> {
}
----

Spring Data generates a working implementation of the specified interface, which can be conveniently autowired into an application.

The `Trader` type parameter to `SpannerRepository` refers to the underlying domain type.
The second type parameter, `String` in this case, refers to the type of the key of the domain type.


For POJOs with a composite primary key, this ID type parameter can be any descendant of `Object[]` compatible with all primary key properties, any descendant of `Iterable`, or `com.google.cloud.spanner.Key`.
If the domain POJO type only has a single primary key column, then the primary key property type can be used or the `Key` type.

For example in case of Trades, that belong to a Trader, `TradeRepository` would look like this:

[source,java]
----
public interface TradeRepository extends SpannerRepository<Trade, String[]> {

}
----

[source,java]
----
public class MyApplication {

	@Autowired
	SpannerTemplate spannerTemplate;

	@Autowired
	StudentRepository studentRepository;

	public void demo() {

		this.tradeRepository.deleteAll();
		String traderId = ""demo_trader"";
		Trade t = new Trade();
		t.symbol = stock;
		t.action = action;
		t.traderId = traderId;
		t.price = new BigDecimal(""100.0"");
		t.shares = 12345.6;
		this.spannerTemplate.insert(t);

		Iterable<Trade> allTrades = this.tradeRepository.findAll();

		int count = this.tradeRepository.countByAction(""BUY"");

	}
}

----

==== CRUD Repository

`CrudRepository` methods work as expected, with one thing Spanner specific: the `save` and `saveAll` methods work as update-or-insert.

==== Paging and Sorting Repository

You can also use `PagingAndSortingRepository` with Spanner Spring Data.
The sorting and pageable `findAll` methods available from this interface operate on the current state of the Spanner database.
As a result, beware that the state of the database (and the results) might change when moving page to page.

==== Spanner Repository

The `SpannerRepository` extends the `PagingAndSortingRepository`, but adds the read-only and the read-write transaction functionality provided by Spanner.
These transactions work very similarly to those of `SpannerOperations`, but is specific to the repository's domain type and provides repository functions instead of template functions.

For example, this is a read-only transaction:

[source,java]
----

@Autowired
SpannerRepository myRepo;

public String doWorkInsideTransaction() {
  return myRepo.performReadOnlyTransaction(
    transactionSpannerRepo -> {
      // Work with the single-transaction transactionSpannerRepo here.
      // This is a SpannerRepository object.

      return ""transaction completed"";
    }
  );
}
----

When creating custom repositories for your own domain types and query methods, you can extend `SpannerRepository` to access Cloud Spanner-specific features as well as all features from `PagingAndSortingRepository` and `CrudRepository`.

=== Query Methods

`SpannerRepository` supports Query Methods.
Described in the following sections, these are methods residing in your custom repository interfaces of which implementations are generated based on their names and annotations.
Query Methods can read, write, and delete entities in Cloud Spanner.
Parameters to these methods can be any Cloud Spanner data type supported directly or via custom configured converters.
Parameters can also be of type `Struct` or POJOs.
If a POJO is given as a parameter, it will be converted to a `Struct` with the same type-conversion logic as used to create write mutations.
Comparisons using Struct parameters are limited to https://cloud.google.com/spanner/docs/data-types#limited-comparisons-for-struct[what is available with Cloud Spanner].


==== Query methods by convention

[source, java]
----
public interface TradeRepository extends SpannerRepository<Trade, String[]> {
    List<Trade> findByAction(String action);

	int countByAction(String action);

	// Named methods are powerful, but can get unwieldy
	List<Trade> findTop3DistinctByActionAndSymbolIgnoreCaseOrTraderIdOrderBySymbolDesc(
  			String action, String symbol, String traderId);
}
----

In the example above, the {spring-data-commons-ref}/#repositories.query-methods[query methods] in `TradeRepository` are generated based on the name of the methods, using the {spring-data-commons-ref}#repositories.query-methods.query-creation[Spring Data Query creation naming convention].

`List<Trade> findByAction(String action)` would translate to a `SELECT * FROM trades WHERE action = ?`.

The function `List<Trade> findTop3DistinctByActionAndSymbolIgnoreCaseOrTraderIdOrderBySymbolDesc(String action, String symbol, String traderId);` will be translated as the equivalent of this SQL query:

[source, sql]
----
SELECT DISTINCT * FROM trades
WHERE ACTION = ? AND LOWER(SYMBOL) = LOWER(?) AND TRADER_ID = ?
ORDER BY SYMBOL DESC
LIMIT 3
----

The following filter options are supported:

* Equality
* Greater than or equals
* Greater than
* Less than or equals
* Less than
* Is null
* Is not null
* Is true
* Is false
* Like a string
* Not like a string
* Contains a string
* Not contains a string
* In
* Not in

Note that the phrase `SymbolIgnoreCase` is translated to `LOWER(SYMBOL) = LOWER(?)` indicating a non-case-sensitive matching.
The `IgnoreCase` phrase may only be appended to fields that correspond to columns of type STRING or BYTES.
The Spring Data ""AllIgnoreCase"" phrase appended at the end of the method name is not supported.

The `Like` or `NotLike` naming conventions:
[source, java]
----
List<Trade> findBySymbolLike(String symbolFragment);
----
The param `symbolFragment` can contain https://cloud.google.com/spanner/docs/functions-and-operators#comparison-operators[wildcard characters] for string matching such as `_` and `%`.

The `Contains` and `NotContains` naming conventions:
[source, java]
----
List<Trade> findBySymbolContains(String symbolFragment);
----
The param `symbolFragment` is a https://cloud.google.com/spanner/docs/functions-and-operators#regexp_contains[regular expression] that is checked for occurrences.

The `In` and `NotIn` keywords must be used with `Iterable` corresponding parameters.

Delete queries are also supported.
For example, query methods such as `deleteByAction` or `removeByAction` delete entities found by `findByAction`.
The delete operation happens in a single transaction.

Delete queries can have the following return types:
* An integer type that is the number of entities deleted
* A collection of entities that were deleted
* `void`

==== Custom SQL/DML query methods

The example above for `List<Trade> fetchByActionNamedQuery(String action)` does not match the {spring-data-commons-ref}#repositories.query-methods.query-creation[Spring Data Query creation naming convention], so we have to map a parametrized Spanner SQL query to it.

The SQL query for the method can be mapped to repository methods in one of two ways:

 * `namedQueries` properties file
 * using the `@Query` annotation

The names of the tags of the SQL correspond to the `@Param` annotated names of the method parameters.

Interleaved properties are loaded eagerly, unless they are annotated with `@Interleaved(lazy = true)`.

Custom SQL query methods can accept a single `Sort` or `Pageable` parameter that is applied on top of the specified custom query.
It is the recommended way to control the sort order of the results, which is not guaranteed by the `ORDER BY` clause in the SQL query.
This is due to the fact that the user-provided query is used as a sub-query, and Cloud Spanner doesn't preserve order in subquery results.

You might want to use `ORDER BY` with `LIMIT` to obtain the top records, according to a specified order.
However, to ensure the correct sort order of the final result set, sort options have to be passed in with a `Pageable`.

[source, java]
----
	@Query(""SELECT * FROM trades"")
	List<Trade> fetchTrades(Pageable pageable);

	@Query(""SELECT * FROM trades ORDER BY price DESC LIMIT 1"")
 	Trade topTrade(Pageable pageable);

----

This can be used:

[source, java]
----
	List<Trade> customSortedTrades = tradeRepository.fetchTrades(PageRequest
  				.of(2, 2, org.springframework.data.domain.Sort.by(Order.asc(""id""))));
----

The results would be sorted by ""id"" in ascending order.

Your query method can also return non-entity types:
[source, java]
----
  	@Query(""SELECT COUNT(1) FROM trades WHERE action = @action"")
  	int countByActionQuery(String action);

  	@Query(""SELECT EXISTS(SELECT COUNT(1) FROM trades WHERE action = @action)"")
  	boolean existsByActionQuery(String action);

  	@Query(""SELECT action FROM trades WHERE action = @action LIMIT 1"")
  	String getFirstString(@Param(""action"") String action);

  	@Query(""SELECT action FROM trades WHERE action = @action"")
  	List<String> getFirstStringList(@Param(""action"") String action);
----

DML statements can also be run by query methods, but the only possible return value is a `long` representing the number of affected rows.
The `dmlStatement` boolean setting must be set on `@Query` to indicate that the query method is run as a DML statement.

[source, java]
----
  	@Query(value = ""DELETE FROM trades WHERE action = @action"", dmlStatement = true)
  	long deleteByActionQuery(String action);
----

===== Query methods with named queries properties

By default, the `namedQueriesLocation` attribute on `@EnableSpannerRepositories` points to the `META-INF/spanner-named-queries.properties` file.
You can specify the query for a method in the properties file by providing the SQL as the value for the ""interface.method"" property:

[source, properties]
----
Trade.fetchByActionNamedQuery=SELECT * FROM trades WHERE trades.action = @tag0
----

[source, java]
----
public interface TradeRepository extends SpannerRepository<Trade, String[]> {
	// This method uses the query from the properties file instead of one generated based on name.
	List<Trade> fetchByActionNamedQuery(@Param(""tag0"") String action);
}
----
===== Query methods with annotation

Using the `@Query` annotation:

[source, java]
----
public interface TradeRepository extends SpannerRepository<Trade, String[]> {
    @Query(""SELECT * FROM trades WHERE trades.action = @tag0"")
    List<Trade> fetchByActionNamedQuery(@Param(""tag0"") String action);
}
----

Table names can be used directly.
For example, ""trades"" in the above example.
Alternatively, table names can be resolved from the `@Table` annotation on domain classes as well.
In this case, the query should refer to table names with fully qualified class names between `:`
characters: `:fully.qualified.ClassName:`.
A full example would look like:

[source, java]
----
@Query(""SELECT * FROM :com.example.Trade: WHERE trades.action = @tag0"")
List<Trade> fetchByActionNamedQuery(String action);
----

This allows table names evaluated with SpEL to be used in custom queries.

SpEL can also be used to provide SQL parameters:

[source, java]
----
@Query(""SELECT * FROM :com.example.Trade: WHERE trades.action = @tag0
  AND price > #{#priceRadius * -1} AND price < #{#priceRadius * 2}"")
List<Trade> fetchByActionNamedQuery(String action, Double priceRadius);
----

When using the `IN` SQL clause, remember to use `IN UNNEST(@iterableParam)` to specify a single `Iterable` parameter.
You can also use a fixed number of singular parameters such as `IN (@stringParam1, @stringParam2)`.

==== Projections
Spring Data Spanner supports {spring-data-commons-ref}/#projections[projections].
You can define projection interfaces based on domain types and add query methods that return them in your repository:

[source, java]
----
public interface TradeProjection {

	String getAction();

	@Value(""#{target.symbol + ' ' + target.action}"")
	String getSymbolAndAction();
}

public interface TradeRepository extends SpannerRepository<Trade, Key> {

	List<Trade> findByTraderId(String traderId);

	List<TradeProjection> findByAction(String action);

	@Query(""SELECT action, symbol FROM trades WHERE action = @action"")
	List<TradeProjection> findByQuery(String action);
}
----

Projections can be provided by name-convention-based query methods as well as by custom SQL queries.
If using custom SQL queries, you can further restrict the columns retrieved from Spanner to just those required by the projection to improve performance.

Properties of projection types defined using SpEL use the fixed name `target` for the underlying domain object.
As a result accessing underlying properties take the form `target.<property-name>`.

==== Empty result handling in repository methods
Java `java.util.Optional` can be used to indicate the potential absence of a return value.

Alternatively, query methods can return the result without a wrapper.
In that case the absence of a query result is indicated by returning `null`.
Repository methods returning collections are guaranteed never to return `null` but rather the corresponding empty collection.

NOTE: You can enable nullability checks. For more details please see https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#null-safety[Spring Framework’s nullability docs].

==== REST Repositories

When running with Spring Boot, repositories can be exposed as REST services by simply adding this dependency to your pom file:
[source,xml]
----
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>
----

If you prefer to configure parameters (such as path), you can use `@RepositoryRestResource` annotation:
[source,java]
----
@RepositoryRestResource(collectionResourceRel = ""trades"", path = ""trades"")
public interface TradeRepository extends SpannerRepository<Trade, Key> {
}
----

NOTE: For classes that have composite keys (multiple `@PrimaryKey` fields), only the `Key` type is supported for the repository ID type.

For example, you can retrieve all `Trade` objects in the repository by using `curl \\http://<server>:<port>/trades`, or any specific trade via `curl \\http://<server>:<port>/trades/<trader_id>,<trade_id>`.

The separator between your primary key components, `id` and `trader_id` in this case, is a comma by default, but can be configured to any string not found in your key values by extending the `SpannerKeyIdConverter` class:

[source,java]
----
@Component
class MySpecialIdConverter extends SpannerKeyIdConverter {

    @Override
    protected String getUrlIdSeparator() {
        return "":"";
    }
}
----

You can also write trades using `curl -XPOST -H""Content-Type: application/json"" -d@test.json \\http://<server>:<port>/trades/` where the file `test.json` holds the JSON representation of a `Trade` object.

=== Database and Schema Admin

Databases and tables inside Spanner instances can be created automatically from `SpannerPersistentEntity` objects:

[source,java]
----
@Autowired
private SpannerSchemaUtils spannerSchemaUtils;

@Autowired
private SpannerDatabaseAdminTemplate spannerDatabaseAdminTemplate;

public void createTable(SpannerPersistentEntity entity) {
	if(!spannerDatabaseAdminTemplate.tableExists(entity.tableName()){

	  // The boolean parameter indicates that the database will be created if it does not exist.
	  spannerDatabaseAdminTemplate.executeDdlStrings(Arrays.asList(
            spannerSchemaUtils.getCreateTableDDLString(entity.getType())), true);
	}
}
----

Schemas can be generated for entire object hierarchies with interleaved relationships and composite keys.

=== Events

Spring Data Cloud Spanner publishes events extending the Spring Framework's `ApplicationEvent` to the context that can be received by `ApplicationListener` beans you register.

[options=""header""]
|===
| Type| Description | Contents
| `AfterReadEvent`|Published immediately after entities are read by key from Cloud Spanner by `SpannerTemplate`| The entities loaded. The read options and key-set originally specified for the load operation.
| `AfterQueryEvent`|Published immediately after entities are read by query from Cloud Spanner by `SpannerTemplate`| The entities loaded. The query options and query statement originally specified for the load operation.
| `BeforeExecuteDmlEvent`|Published immediately before DML statements are executed by `SpannerTemplate`| The DML statement to execute.
| `AfterExecuteDmlEvent`|Published immediately after DML statements are executed by `SpannerTemplate`| The DML statement to execute and the number of rows affected by the operation as reported by Cloud Spanner.
| `BeforeSaveEvent`|Published immediately before upsert/update/insert operations are executed by `SpannerTemplate`| The mutations to be sent to Cloud Spanner, the entities to be saved, and optionally the properties in those entities to save.
| `AfterSaveEvent`|Published immediately after upsert/update/insert operations are executed by `SpannerTemplate`| The mutations sent to Cloud Spanner, the entities to be saved, and optionally the properties in those entities to save.
| `BeforeDeleteEvent`|Published immediately before delete operations are executed by `SpannerTemplate`| The mutations to be sent to Cloud Spanner. The target entities, keys, or entity type originally specified for the delete operation.
| `AfterDeleteEvent`|Published immediately after delete operations are executed by `SpannerTemplate`| The mutations sent to Cloud Spanner. The target entities, keys, or entity type originally specified for the delete operation.
|===


=== Auditing

Spring Data Cloud Spanner supports the `@LastModifiedDate` and `@LastModifiedBy` auditing annotations for properties:

[source,java]
----
@Table
public class SimpleEntity {
    @PrimaryKey
    String id;

    @LastModifiedBy
    String lastUser;

    @LastModifiedDate
    DateTime lastTouched;
}
----

Upon insert, update, or save, these properties will be set automatically by the framework before mutations are generated and saved to Cloud Spanner.

To take advantage of these features, add the `@EnableSpannerAuditing` annotation to your configuration class and provide a bean for an `AuditorAware<A>` implementation where the type `A` is the desired property type annotated by `@LastModifiedBy`:

[source,java]
----
@Configuration
@EnableSpannerAuditing
public class Config {

    @Bean
    public AuditorAware<String> auditorProvider() {
        return () -> Optional.of(""YOUR_USERNAME_HERE"");
    }
}
----

The `AuditorAware` interface contains a single method that supplies the value for fields annotated by `@LastModifiedBy` and can be of any type.
One alternative is to use Spring Security's `User` type:

[source,java]
----
class SpringSecurityAuditorAware implements AuditorAware<User> {

  public Optional<User> getCurrentAuditor() {

    return Optional.ofNullable(SecurityContextHolder.getContext())
			  .map(SecurityContext::getAuthentication)
			  .filter(Authentication::isAuthenticated)
			  .map(Authentication::getPrincipal)
			  .map(User.class::cast);
  }
}
----

You can also set a custom provider for properties annotated `@LastModifiedDate` by providing a bean for `DateTimeProvider` and providing the bean name to `@EnableSpannerAuditing(dateTimeProviderRef = ""customDateTimeProviderBean"")`.

=== Multi-Instance Usage

Your application can be configured to use multiple Cloud Spanner instances or databases by providing a custom bean for `DatabaseIdProvider`.
The default bean uses the instance ID, database name, and project ID options you configured in `application.properties`.

[source,java]
----
    @Bean
    public DatabaseIdProvider databaseIdProvider() {
        // return custom connection options provider
    }
----

The `DatabaseId` given by this provider is used as the target database name and instance of each operation Spring Data Cloud Spanner executes.
By providing a custom implementation of this bean (for example, supplying a thread-local `DatabaseId`), you can direct your application to use multiple instances or databases.

Database administrative operations, such as creating tables using `SpannerDatabaseAdminTemplate`, will also utilize the provided `DatabaseId`.

If you would like to configure every aspect of each connection (such as pool size and retry settings), you can supply a bean for `Supplier<DatabaseClient>`.


=== Cloud Spanner Emulator

The https://cloud.google.com/sdk[Cloud SDK] provides a local, in-memory emulator for Cloud Spanner, which you can use to develop and test your application. As the emulator stores data only in memory, it will not persist data across runs. It is intended to help you use Cloud Spanner for local development and testing, not for production deployments.

In order to set up and start the emulator, you can follow https://cloud.google.com/spanner/docs/emulator[these steps].

This command can be used to create Cloud Spanner instances:

----
$ gcloud spanner instances create <instance-name> --config=emulator-config --description=""<description>"" --nodes=1
----

Once the Spanner emulator is running, ensure that the following properties are set in your `application.properties` of your Spring application:

----
spring.cloud.gcp.spanner.emulator.enabled=true
spring.cloud.gcp.spanner.emulator-host=${EMULATOR_HOSTPORT}
----

=== Sample

A https://github.com/GoogleCloudPlatform/spring-cloud-gcp/tree/main/spring-cloud-gcp-samples/spring-cloud-gcp-data-spanner-sample[sample application] is available.
",12227,False,2047.5951556008895,median
"[[configuration-interfaces]]
== Set traffic capturing options

There are two main ways of deploying Packetbeat:

* On dedicated servers, getting the traffic from mirror ports or tap devices.

* On your existing application servers.

The first option has the big advantage that there is no overhead of any kind on
your application servers. But it requires dedicated networking gear, which is
generally not available on cloud setups.

In both cases, the sniffing performance (reading packets passively from the network)
is very important. In the case of a dedicated server, better
sniffing performance means that less hardware is required. When Packetbeat is installed
on an existing application server, better sniffing performance means less overhead.

Currently Packetbeat has several options for traffic capturing:

 * `pcap`, which uses the libpcap library and works on most platforms, but
   it's not the fastest option.
 * `af_packet`, which uses memory mapped sniffing. This option is faster than libpcap
    and doesn't require a kernel module, but it's Linux-specific.

The `af_packet` option, also known as ""memory-mapped sniffing,"" makes use of a
Linux-specific
http://lxr.free-electrons.com/source/Documentation/networking/packet_mmap.txt[feature].
This could be the optimal sniffing mode for both the dedicated server and
when Packetbeat is deployed on an existing application server.

The way it works is that both the kernel and the user space program map the
same memory zone, and a simple circular buffer is organized in this memory zone.
The kernel writes packets into the circular buffer, and the user space program
reads from it. The poll system call is used for getting a notification for the
first packet available, but the remaining available packets can be simply read
via memory access.

The `af_packet` sniffer can be further tuned to use more memory in exchange for
better performance. The larger the size of the circular buffer, the fewer
system calls are needed, which means that fewer CPU cycles are consumed. The default size
of the buffer is 30 MB, but you can increase it like this:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.interfaces.device: eth0
packetbeat.interfaces.type: af_packet
packetbeat.interfaces.buffer_size_mb: 100
------------------------------------------------------------------------------


[float]
=== Sniffing configuration options

You can specify the following options in the `packetbeat.interfaces` section
of the +{beatname_lc}.yml+ config file. Here is an example configuration:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.interfaces.device: any
packetbeat.interfaces.snaplen: 1514
packetbeat.interfaces.type: af_packet
packetbeat.interfaces.buffer_size_mb: 100
------------------------------------------------------------------------------

[float]
==== `device`

The network device to capture traffic from. The specified device is set automatically to promiscuous mode,
meaning that Packetbeat can capture traffic from other hosts on the same LAN.

Example:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.interfaces.device: eth0
------------------------------------------------------------------------------

On Linux, you can specify `any` for the device, and Packetbeat captures all
messages sent or received by the server where Packetbeat is installed.

NOTE: When you specify `any` for the device, the interfaces are not set
      to promiscuous mode.

The `device` option also accepts specifying the device by its index in the list of
devices available for sniffing. To obtain the list of available devices,
run Packetbeat with the following command:

[""source"",""sh"",subs=""attributes,callouts""]
----------------------------------------------------------------------
packetbeat devices
----------------------------------------------------------------------

This command returns a list that looks something like the following:

[""source"",""sh"",subs=""attributes,callouts""]
----------------------------------------------------------------------
0: en0 (No description available)
1: awdl0 (No description available)
2: bridge0 (No description available)
3: fw0 (No description available)
4: en1 (No description available)
5: en2 (No description available)
6: p2p0 (No description available)
7: en4 (No description available)
8: lo0 (No description available)
----------------------------------------------------------------------

The following example sets up sniffing on the
first interface in the list:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.interfaces.device: 0
------------------------------------------------------------------------------

Specifying the index is especially useful on Windows where device names can be long.

[float]
==== `snaplen`

The maximum size of the packets to capture. The
default is 65535, which is large enough for almost all networks and interface
types. If you sniff on a physical network interface, the optimal setting is
the MTU size. On virtual interfaces, however, it's safer to accept the default value.

Example:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.interfaces.device: eth0
packetbeat.interfaces.snaplen: 1514
------------------------------------------------------------------------------

[float]
==== `type`

Packetbeat supports these sniffer types:

 * `pcap`, which uses the libpcap library and works on most platforms, but
   it's not the fastest option.
 * `af_packet`, which uses memory-mapped sniffing. This option is faster than libpcap
   and doesn't require a kernel module, but it's Linux-specific.

The default sniffer type is `pcap`.

Here is an example configuration that specifies
the `af_packet` sniffing type:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.interfaces.device: eth0
packetbeat.interfaces.type: af_packet
------------------------------------------------------------------------------

On Linux, if you are trying to optimize the CPU usage of Packetbeat, we
recommend trying the `af_packet` option.

If you use the `af_packet` sniffer, you can tune its behaviour by specifying the
following options:

[float]
==== `buffer_size_mb`

The maximum size of the shared memory buffer to use
between the kernel and user space. A bigger buffer usually results in lower CPU
usage, but consumes more memory. This setting is only available for the
`af_packet` sniffer type. The default is 30 MB.

Example:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.interfaces.device: eth0
packetbeat.interfaces.type: af_packet
packetbeat.interfaces.buffer_size_mb: 100
------------------------------------------------------------------------------

[float]
==== `with_vlans`

Packetbeat automatically generates a
https://en.wikipedia.org/wiki/Berkeley_Packet_Filter[BPF] for capturing only
the traffic on ports where it expects to find known protocols.
For example, if you have configured port 80 for HTTP and port 3306 for MySQL,
Packetbeat generates the following BPF filter: `""port 80 or port 3306""`.

However, if the traffic contains https://en.wikipedia.org/wiki/IEEE_802.1Q[VLAN]
tags, the filter that Packetbeat generates is ineffective because the
offset is moved by four bytes. To fix this, you can enable the `with_vlans` option, which
generates a BPF filter that looks like this: `""port 80 or port 3306 or (vlan and (port 80 or port 3306))""`.

[float]
==== `bpf_filter`

Packetbeat automatically generates a
https://en.wikipedia.org/wiki/Berkeley_Packet_Filter[BPF] for capturing only
the traffic on ports where it expects to find known protocols.
For example, if you have configured port 80 for HTTP and port 3306 for MySQL,
Packetbeat generates the following BPF filter: `""port 80 or port 3306""`.

You can use the `bpf_filter` setting to overwrite the generated BPF filter. For example:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.interfaces.device: eth0
packetbeat.interfaces.bpf_filter: ""net 192.168.238.0/0 and port 80 or port 3306""
------------------------------------------------------------------------------

NOTE: This setting disables automatic generation of the BPF filter. If
you use this setting, it's your responsibility to keep the BPF filters in sync with the
ports defined in the `protocols` section.

[float]
==== `ignore_outgoing`

If the `ignore_outgoing` option is enabled, Packetbeat ignores all the
transactions initiated from the server running Packetbeat.

This is useful when two Packetbeat instances publish the same transactions. Because one Packetbeat
sees the transaction in its outgoing queue and the other sees it in its incoming
queue, you can end up with duplicate transactions. To remove the duplicates, you
can enable the `packetbeat.ignore_outgoing` option on one of the servers.

For example, in the following scenario, you see a 3-server architecture
where a Beat is installed on each server. t1 is the transaction exchanged between
Server1 and Server2, and t2 is the transaction between Server2 and Server3.

image::./images/option_ignore_outgoing.png[Beats Architecture]

By default, each transaction is indexed twice because Beat2
sees both transactions. So you would see the following published transactions
(when `ignore_outgoing` is false):

 - Beat1: t1
 - Beat2: t1 and t2
 - Beat3: t2

To avoid duplicates, you can force your Beats to send only the incoming
transactions and ignore the transactions created by the local server. So you would
see the following published transactions (when `ignore_outgoing` is true):

 - Beat1: none
 - Beat2: t1
 - Beat3: t2


[[configuration-flows]]
== Set up flows to monitor network traffic

You can configure Packetbeat to collect and report statistics on network flows.
A _flow_ is a group of packets sent over the same time period that share
common properties, such as the same source and destination address and protocol.
You can use this feature to analyze network traffic over specific protocols on
your network.

For each flow, Packetbeat reports the number of packets and the total number of
bytes sent from the source to the destination. Each flow event also contains
information about the source and destination hosts, such as their IP address.
For bi-directional flows, Packetbeat reports statistics for the reverse flow.

Packetbeat collects and reports statistics up to and including the transport
layer. See <<exported-fields-flows_event>> for more info about the exported
data.

Here's an example of flow events visualized in the Flows dashboard:

image::./images/flows.png[]

To configure flows, use the `packetbeat.flows` option in the +{beatname_lc}.yml+
config file. Flows are enabled by default. If this section is missing
from the configuration file, network flows are disabled.

[source,yaml]
--------------------------------------------------------------------------------
packetbeat.flows:
  timeout: 30s
  period: 10s
--------------------------------------------------------------------------------

Here’s an example of a flow information sent by Packetbeat. See
<<exported-fields-flows_event>> for a description of each field.

[""source"",""json"",subs=""attributes""]
--------------------------------------------------------------------------------
{
  ""@timestamp"": ""2018-11-15T14:41:24.000Z"",
  ""agent"": {
    ""hostname"": ""host.example.com"",
    ""name"": ""host.example.com"",
    ""version"": ""{version}""
  },
  ""destination"": {
    ""bytes"": 460,
    ""ip"": ""198.51.100.2"",
    ""mac"": ""06:05:04:03:02:01"",
    ""packets"": 2,
    ""port"": 80
  },
  ""event"": {
    ""dataset"": ""flow"",
    ""duration"": 3000000000,
    ""end"": ""2018-11-15T14:41:24.000Z"",
    ""start"": ""2018-11-15T14:41:21.000Z""
  },
  ""flow"": {
    ""final"": true, <1>
    ""id"": ""FQQA/wz/Dv//////Fv8BAQEBAgMEBQYGBQQDAgGrAMsAcQPGM2QC9ZdQAA"",
    ""vlan"": 171
  },
  ""network"": {
    ""bytes"": 470,
    ""community_id"": ""1:t9T66/2c66NQyftAEsr4aMZv4Hc="",
    ""packets"": 3,
    ""transport"": ""tcp"",
    ""type"": ""ipv4""
  },
  ""source"": {
    ""bytes"": 10,
    ""ip"": ""203.0.113.3"",
    ""mac"": ""01:02:03:04:05:06"",
    ""packets"": 1,
    ""port"": 38901
  }
}
--------------------------------------------------------------------------------

<1> Packetbeat sets the `flow.final` flag to `false` to indicate that the event
contains an intermediate report about a flow that it's tracking. When the flow
completes, Packetbeat sends one last event with `flow.final` set to `true`. If
you want to aggregate sums of traffic, you need to filter on `final:true`, or
use some other technique, so that you get only the latest update from each flow.
You can disable intermediate reports by setting `period: -1s`.

[float]
=== Configuration options

You can specify the following options in the `packetbeat.flows` section of
the +{beatname_lc}.yml+ config file:

[float]
==== `enabled`

Enables flows support if set to true. Set to false to disable network flows
support without having to delete or comment out the flows section. The default
value is true.

[float]
==== `timeout`

Timeout configures the lifetime of a flow. If no packets have been received for
a flow within the timeout time window, the flow is killed and reported. The
default value is 30s.

[float]
==== `period`

Configure the reporting interval. All flows are reported at the very same point
in time. Periodical reporting can be disabled by setting the value to -1. If
disabled, flows are still reported once being timed out. The default value is
10s.

[float]
[[packetbeat-configuration-flows-fields]]
==== `fields`

Optional fields that you can specify to add additional information to the
output. For example, you might add fields that you can use for filtering log
data. Fields can be scalar values, arrays, dictionaries, or any nested
combination of these. By default, the fields that you specify here will be
grouped under a `fields` sub-dictionary in the output document. To store the
custom fields as top-level fields, set the `fields_under_root` option to true.
If a duplicate field is declared in the general configuration, then its value
will be overwritten by the value declared here.

[float]
==== `fields_under_root`

If this option is set to true, the custom <<packetbeat-configuration-flows-fields,fields>>
are stored as top-level fields in the output document instead of being grouped
under a `fields` sub-dictionary. If the custom field names conflict with other
field names added by Packetbeat, then the custom fields overwrite the other
fields.

[float]
==== `tags`

A list of tags that will be sent with the protocol event. This setting is optional.

[float]
==== `processors`

A list of processors to apply to the data generated by the protocol.

See <<filtering-and-enhancing-data>> for information about specifying
processors in your config.

[float]
==== `keep_null`

If this option is set to true, fields with `null` values will be published in
the output document. By default, `keep_null` is set to `false`.

[[configuration-protocols]]
== Specify which transaction protocols to monitor

The `packetbeat.protocols` section of the +{beatname_lc}.yml+ config file
contains configuration options for each supported protocol, including common
options like `enabled`, `ports`, `send_request`, `send_response`, and options
that are protocol-specific.

Currently, Packetbeat supports the following protocols:

include::./shared-protocol-list.asciidoc[]

Example configuration:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.protocols:

- type: icmp
  enabled: true

- type: dhcpv4
  ports: [67, 68]

- type: dns
  ports: [53]

- type: http
  ports: [80, 8080, 8000, 5000, 8002]

- type: amqp
  ports: [5672]

- type: cassandra
  ports: [9042]

- type: memcache
  ports: [11211]

- type: mysql
  ports: [3306,3307]

- type: redis
  ports: [6379]

- type: pgsql
  ports: [5432]

- type: thrift
  ports: [9090]

- type: tls
  ports: [443, 993, 995, 5223, 8443, 8883, 9243]

------------------------------------------------------------------------------

[[common-protocol-options]]
=== Common protocol options

The following options are available for all protocols:

[float]
==== `enabled`

The enabled setting is a boolean setting to enable or disable protocols without
having to comment out configuration sections. If set to false, the protocol is
disabled.

The default value is true.

[float]
==== `ports`

Exception: For ICMP the option `enabled` has to be used instead.

The ports where Packetbeat will look to capture traffic for specific
protocols. Packetbeat installs a https://en.wikipedia.org/wiki/Berkeley_Packet_Filter[BPF]
filter based on the ports specified in this section.
If a packet doesn't match the filter, very little CPU is required to discard
the packet. Packetbeat also uses the ports specified here to determine which
parser to use for each packet.

[float]
[[send-request-option]]
==== `send_request`

If this option is enabled, the raw message of the request (`request` field) is
sent to Elasticsearch. The default is false. This option is useful when you want to
index the whole request. Note that for HTTP, the body is not included by
default, only the HTTP headers.

[float]
[[send-response-option]]
==== `send_response`

If this option is enabled, the raw message of the response (`response` field)
is sent to Elasticsearch. The default is false.  This option is useful when you
want to index the whole response. Note that for HTTP, the body is not included
by default, only the HTTP headers.

[float]
[[transaction-timeout-option]]
==== `transaction_timeout`

The per protocol transaction timeout. Expired transactions will no longer be correlated to incoming responses, but sent to Elasticsearch immediately.

[float]
[[packetbeat-configuration-fields]]
==== `fields`

Optional fields that you can specify to add additional information to the
output. For example, you might add fields that you can use for filtering log
data. Fields can be scalar values, arrays, dictionaries, or any nested
combination of these. By default, the fields that you specify here will be
grouped under a `fields` sub-dictionary in the output document. To store the
custom fields as top-level fields, set the `fields_under_root` option to true.
If a duplicate field is declared in the general configuration, then its value
will be overwritten by the value declared here.

[source,yaml]
--------------------------------------------------------------------------------
packetbeat.protocols:
- type: http
  ports: [80]
  fields:
    service_id: nginx
--------------------------------------------------------------------------------

[float]
[[packetbeat-fields-under-root]]
==== `fields_under_root`

If this option is set to true, the custom <<packetbeat-configuration-fields,fields>>
are stored as top-level fields in the output document instead of being grouped
under a `fields` sub-dictionary. If the custom field names conflict with other
field names added by Packetbeat, then the custom fields overwrite the other
fields.

[float]
==== `tags`

A list of tags that will be sent with the transaction event. This setting is optional.

[float]
==== `processors`

A list of processors to apply to the data generated by the protocol.

See <<filtering-and-enhancing-data>> for information about specifying
processors in your config.

[float]
==== `keep_null`

If this option is set to true, fields with `null` values will be published in
the output document. By default, `keep_null` is set to `false`.

[[packetbeat-icmp-options]]
=== Capture ICMP traffic

++++
<titleabbrev>ICMP</titleabbrev>
++++

The `icmp` section of the +{beatname_lc}.yml+ config file specifies options for
the ICMP protocol. Here is a sample configuration section for ICMP:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.protocols:

- type: icmp
  enabled: true
------------------------------------------------------------------------------

==== Configuration options

Also see <<common-protocol-options>>.

===== `enabled`

The ICMP protocol can be enabled/disabled via this option. The default is true.

If enabled Packetbeat will generate the following BPF filter: `""icmp or icmp6""`.

[[packetbeat-dns-options]]
=== Capture DNS traffic

++++
<titleabbrev>DNS</titleabbrev>
++++

The `dns` section of the +{beatname_lc}.yml+ config file specifies configuration
options for the DNS protocol. The DNS protocol supports processing DNS messages
on TCP and UDP. Here is a sample configuration section for DNS:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.protocols:
- type: dns
  ports: [53]
  include_authorities: true
  include_additionals: true
------------------------------------------------------------------------------

==== Configuration options

Also see <<common-protocol-options>>.

===== `include_authorities`

If this option is enabled, dns.authority fields (authority resource records) are
added to DNS events. The default is false.

===== `include_additionals`

If this option is enabled, dns.additionals fields (additional resource records)
are added to DNS events. The default is false.

[[packetbeat-http-options]]
=== Capture HTTP traffic

++++
<titleabbrev>HTTP</titleabbrev>
++++

The HTTP protocol has several specific configuration options. Here is a
sample configuration for the `http` section of the +{beatname_lc}.yml+ config file:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.protocols:
- type: http
  ports: [80, 8080, 8000, 5000, 8002]
  hide_keywords: [""pass"", ""password"", ""passwd""]
  send_headers: [""User-Agent"", ""Cookie"", ""Set-Cookie""]
  split_cookie: true
  real_ip_header: ""X-Forwarded-For""
------------------------------------------------------------------------------

==== Configuration options

Also see <<common-protocol-options>>.

===== `hide_keywords`

A list of query parameters that Packetbeat will automatically censor in
the transactions that it saves. The values associated with these parameters are replaced
by `'xxxxx'`. By default, no changes are made to the HTTP messages.

Packetbeat has this option because, unlike SQL traffic, which typically only contains the
hashes of the passwords, HTTP traffic may contain sensitive data. To reduce security risks,
you can configure this option to avoid sending the contents of certain HTTP POST
parameters.

WARNING: This option replaces query parameters from GET requests and top-level
parameters from POST requests. If sensitive data is encoded inside a
parameter that you don't specify here, Packetbeat cannot censor it. Also, note that if
you configure Packetbeat to save the raw request and response fields (see the <<send-request-option>>
and the <<send-response-option>> options), sensitive data may be present in those
fields.

===== `redact_authorization`

When this option is enabled, Packetbeat obscures the value of
`Authorization` and `Proxy-Authorization` HTTP headers, and censors
those strings in the response.

You should set this option to true for transactions that use Basic Authentication because
they may contain the base64 unencrypted username and password.

===== `send_headers`

A list of header names to capture and send to Elasticsearch. These
headers are placed under the `headers` dictionary in the resulting JSON.

===== `send_all_headers`

Instead of sending a white list of headers to Elasticsearch, you can
send all headers by setting this option to true. The default is false.

===== `redact_headers`

A list of headers to redact if present in the HTTP request. This will keep
the header field present, but will redact it's value to show the header's
presence.

===== `include_body_for`

The list of content types for which Packetbeat exports the full HTTP payload. The HTTP body is available under
`http.request.body.content` and `http.response.body.content` for these Content-Types.

In addition, if <<send-response-option>> option is enabled, then the HTTP body is exported together with the HTTP
headers under `response` and if
<<send-request-option>> enabled, then `request` contains the entire HTTP message including the body.

In the following example, the HTML attachments of the HTTP responses are exported under the `response` field and under
`http.request.body.content` or `http.response.body.content`:

[source,yml]
------------------------------------------------------------------------------
packetbeat.protocols:
- type: http
  ports: [80, 8080]
  send_response: true
  include_body_for: [""text/html""]
------------------------------------------------------------------------------

===== `decode_body`

A boolean flag that controls decoding of HTTP payload. It interprets the
`Content-Encoding` and `Transfer-Encoding` headers and uncompresses the entity
body. Supported encodings are `gzip` and `deflate`. This option is only
applicable in the cases where the HTTP payload is exported, that is, when
one of the `include_*_body_for` options is specified or a POST request
contains url-encoded parameters.

===== `split_cookie`

If the `Cookie` or `Set-Cookie` headers are sent, this option controls whether
they are split into individual values. For example, with this option set, an
HTTP response might result in the following JSON:

[source,json]
------------------------------------------------------------------------------
""response"": {
  ""code"": 200,
  ""headers"": {
    ""connection"": ""close"",
    ""content-language"": ""en"",
    ""content-type"": ""text/html; charset=utf-8"",
    ""date"": ""Fri, 21 Nov 2014 17:07:34 GMT"",
    ""server"": ""gunicorn/19.1.1"",
    ""set-cookie"": { <1>
      ""csrftoken"": ""S9ZuJF8mvIMT5CL4T1Xqn32wkA6ZSeyf"",
      ""expires"": ""Fri, 20-Nov-2015 17:07:34 GMT"",
      ""max-age"": ""31449600"",
      ""path"": ""/""
    },
    ""vary"": ""Cookie, Accept-Language""
  },
  ""status_phrase"": ""OK""
}
------------------------------------------------------------------------------

<1> Note that `set-cookie` is a map containing the cookie names as keys.

The default is false.

===== `real_ip_header`

The header field to extract the real IP from. This setting is useful when you
want to capture traffic behind a reverse proxy, but you want to get the
geo-location information. If this header is present and contains a valid IP
addresses, the information is used for the `network.forwarded_ip` field.

===== `max_message_size`

If an individual HTTP message is larger than this setting (in bytes), it will be trimmed
to this size. Unless this value is very small (<1.5K), Packetbeat is able to still correctly
follow the transaction and create an event for it. The default is 10485760 (10 MB).

[[packetbeat-amqp-options]]
=== Capture AMQP traffic

++++
<titleabbrev>AMQP</titleabbrev>
++++

The `amqp` section of the +{beatname_lc}.yml+ config file specifies configuration options for the AMQP 0.9.1
protocol. Here is a sample configuration:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.protocols:
- type: amqp
  ports: [5672]
  max_body_length: 1000
  parse_headers: true
  parse_arguments: false
  hide_connection_information: true
------------------------------------------------------------------------------


==== Configuration options

Also see <<common-protocol-options>>.

===== `max_body_length`

The maximum size in bytes of the message displayed in the request or response fields.
Messages that are bigger than the specified size are truncated. Use this option to
avoid publishing huge messages when <<send-request-option>> or <<send-request-option>>
is enabled. The default is 1000 bytes.

===== `parse_headers`

If set to true, Packetbeat parses the additional arguments specified in the headers field
of a message. Those arguments are key-value pairs that specify information such as the
content type of the message or the message priority. The default is true.

===== `parse_arguments`

If set to true, Packetbeat parses the additional arguments specified in AMQP methods.
Those arguments are key-value pairs specified by the user and can be of any length.
The default is true.

===== `hide_connection_information`

If set to false, the connection layer methods of the protocol are also
displayed, such as the opening and closing of connections and channels by clients,
or the quality of service negotiation. The default is true.


[[configuration-cassandra]]
=== Capture Cassandra traffic

++++
<titleabbrev>Cassandra</titleabbrev>
++++

The following settings are specific to the Cassandra protocol. Here is a sample
configuration for the `cassandra` section of the +{beatname_lc}.yml+ config file:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.protocols:
- type: cassandra
  send_request_header: true
  send_response_header: true
  compressor: ""snappy""
  ignored_ops: [""SUPPORTED"",""OPTIONS""]
------------------------------------------------------------------------------

==== Configuration options

Also see <<common-protocol-options>>.

===== `send_request_header`

If this option is enabled, the raw message of the response (`cassandra_request.request_headers` field)
is sent to Elasticsearch. The default is true. enable `send_request` first before enable this option.

===== `send_response_header`

If this option is enabled, the raw message of the response (`cassandra_response.response_headers` field)
is included in published events. The default is true. enable `send_response` first before enable this option.

===== `ignored_ops`

This option indicates which Operator/Operators captured will be ignored. currently support:
`ERROR` ,`STARTUP` ,`READY` ,`AUTHENTICATE` ,`OPTIONS` ,`SUPPORTED` ,
`QUERY` ,`RESULT` ,`PREPARE` ,`EXECUTE` ,`REGISTER`  ,`EVENT` ,
`BATCH` ,`AUTH_CHALLENGE`,`AUTH_RESPONSE` ,`AUTH_SUCCESS` .

===== `compressor`

Configures the default compression algorithm being used to uncompress compressed frames by name. Currently only `snappy` is can be configured.
By default no compressor is configured.

[[packetbeat-memcache-options]]
=== Capture Memcache traffic

++++
<titleabbrev>Memcache</titleabbrev>
++++

The `memcache` section of the +{beatname_lc}.yml+ config file specifies configuration options for the memcache
protocol. Here is a sample configuration section for memcache:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.protocols:
- type: memcache
  ports: [11211]
  parseunknown: false
  maxvalues: 0
  maxbytespervalue: 100
  transaction_timeout: 200
  udptransactiontimeout: 200
------------------------------------------------------------------------------


==== Configuration options

Also see <<common-protocol-options>>.

===== `parseunknown`

When this option is enabled, it forces the memcache text protocol parser to accept unknown commands.

NOTE: The unknown commands MUST NOT contain a data part.

===== `maxvalues`

The maximum number of values to store in the message (multi-get).
All values will be base64 encoded.

The possible settings for this option are:

* `maxvalue: -1`, which stores all values (text based protocol multi-get)
* `maxvalue: 0`, which stores no values (default)
* `maxvalue: N`, which stores up to N values

===== `maxbytespervalue`

The maximum number of bytes to be copied for each value element.

NOTE: Values will be base64 encoded, so the actual size in the JSON document will be 4 times the value that
you specify for `maxbytespervalue`.

===== `udptransactiontimeout`

The transaction timeout in milliseconds. The defaults is 10000 milliseconds.

NOTE: Quiet messages in UDP binary protocol get responses only if there is an error.
The memcache protocol analyzer will wait for the number of milliseconds specified by
`udptransactiontimeout` before publishing quiet messages. Non-quiet messages or
quiet requests with an error response are published immediately.

[[packetbeat-mysql-options]]
=== Capture MySQL traffic

++++
<titleabbrev>MySQL</titleabbrev>
++++

The `mysql` section of the +{beatname_lc}.yml+ config file specifies configuration
options for the MySQL protocols.

[source,yaml]
------------------------------------------------------------------------------
packetbeat.protocols:

- type: mysql
  ports: [3306,3307]
------------------------------------------------------------------------------

==== Configuration options

Also see <<common-protocol-options>>.

===== `max_rows`

The maximum number of rows from the SQL message to publish to Elasticsearch. The
default is 10 rows.


===== `max_row_length`

The maximum length in bytes of a row from the SQL message to publish to
Elasticsearch. The default is 1024 bytes.

==== `statement_timeout`

The duration for which prepared statements are cached after their last use.
Valid time units are ""ns"", ""us"" (or ""µs""), ""ms"", ""s"", ""m"", ""h"".
The default is `1h`.

[[packetbeat-pgsql-options]]
=== Capture PgSQL traffic

++++
<titleabbrev>PgSQL</titleabbrev>
++++

The `pgsql` sections of the +{beatname_lc}.yml+ config file specifies configuration
options for the PgSQL protocols.

[source,yaml]
------------------------------------------------------------------------------
packetbeat.protocols:

- type: pgsql
  ports: [5432]
------------------------------------------------------------------------------

==== Configuration options

Also see <<common-protocol-options>>.

===== `max_rows`

The maximum number of rows from the SQL message to publish to Elasticsearch. The
default is 10 rows.


===== `max_row_length`

The maximum length in bytes of a row from the SQL message to publish to
Elasticsearch. The default is 1024 bytes.

[[configuration-thrift]]
=== Capture Thrift traffic

++++
<titleabbrev>Thrift</titleabbrev>
++++

https://thrift.apache.org/[Apache Thrift] is a communication protocol and RPC
framework initially created at Facebook. It is sometimes used in
http://martinfowler.com/articles/microservices.html[microservices]
architectures because it provides better performance when compared to the more
obvious HTTP/RESTful API choice, while still supporting a wide range of
programming languages and frameworks.

Packetbeat works based on a copy of the traffic, which means that you get
performance management features without having to modify your services in
any way and without any latency overhead. Packetbeat captures the transactions from the
network and indexes them in Elasticsearch so that they can be analyzed and
searched.

Packetbeat indexes the method, parameters, return value, and
exceptions of each Thrift-RPC call. You can search by and create statistics
based on any of these fields. Packetbeat automatically fills in the `status`
column with either `OK` or `Error`, so it's easy to find the problematic RPC calls.
A transaction is put into the `Error` state if it returned an exception.

Packetbeat also indexes the `event.duration` field so you can get performance
analytics and find the slow RPC calls.

Here is an example performance dashboard:

image::./images/thrift-dashboard.png[Thrift-RPC dashboard]


Thrift supports multiple http://en.wikipedia.org/wiki/Apache_Thrift[transport
and protocol types]. Currently Packetbeat supports the default `TSocket`
transport as well as the `TFramed` transport. From the protocol point of view,
Packetbeat currently supports only the default `TBinary` protocol.

Packetbeat also has several configuration options that allow you to get
the right balance between visibility, disk usage, and data protection. You can,
for example, choose to obfuscate all strings or to store the requests but not
the responses, while still capturing the response time for each of the RPC
calls. You can also choose to limit the size of strings and lists to a given
number of elements, so you can fine tune how much data you want to have stored in
Elasticsearch.

The Thrift protocol has several specific configuration options. Here is an
example configuration section for the Thrift protocol in the
+{beatname_lc}.yml+ config file:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.protocols:
- type: thrift
  transport_type: socket
  protocol_type: binary
  idl_files: [""tutorial.thrift"", ""shared.thrift""]
  string_max_size: 200
  collection_max_size: 20
  capture_reply: true
  obfuscate_strings: true
  drop_after_n_struct_fields: 100
------------------------------------------------------------------------------

Providing the Thrift IDL files to Packetbeat is optional. The binary
Thrift messages include the called method name and enough structural information
to decode the messages without needing the IDL files. However, if you
provide the IDL files, Packetbeat can also resolve the service name,
arguments, and exception names.

==== Configuration options

Also see <<common-protocol-options>>.

===== `transport_type`

The Thrift transport type. Currently this option accepts the values `socket`
for TSocket, which is the default Thrift transport, and `framed` for the TFramed Thrift
transport. The default is `socket`.

===== `protocol_type`

The Thrift protocol type. Currently the only accepted value is `binary` for
the TBinary protocol, which is the default Thrift protocol.

===== `idl_files`

The Thrift interface description language (IDL) files for the service that
Packetbeat is monitoring. Providing the IDL files is optional, because the Thrift
messages contain enough information to decode them without having the IDL
files. However, providing the IDL enables Packetbeat to include parameter and
exception names.

===== `string_max_size`

The maximum length for strings in parameters or return values. If a string is longer than
this value, the string is automatically truncated to this length. Packetbeat adds dots
at the end of the string to mark that it was truncated. The default is 200.

===== `collection_max_size`

The maximum number of elements in a Thrift list, set, map, or structure. If a collection
has more elements than this value, Packetbeat captures only the
specified number of elements. Packetbeat adds a fictive last element `...` to the end
of the collection to mark that it was truncated. The default is 15.

===== `capture_reply`

If this option is set to false, Packetbeat decodes the method name from
the reply and simply skips the rest of the response message. This setting can be useful
for performance, disk usage, or data retention reasons. The default is true.

===== `obfuscate_strings`

If this option is set to true, Packetbeat replaces all strings found in method parameters,
return codes, or exception structures with the `""*""` string.

===== `drop_after_n_struct_fields`

The maximum number of fields that a structure can have before Packetbeat
ignores the whole transaction. This is a memory protection mechanism (so that
Packetbeat's memory doesn't grow indefinitely), so you would typically set this
to a relatively high value. The default is 500.


[[configuration-mongodb]]
=== Capture MongoDB traffic

++++
<titleabbrev>MongoDB</titleabbrev>
++++

The following settings are specific to the MongoDB protocol. Here is a sample
configuration for the `mongodb` section of the +{beatname_lc}.yml+ config file:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.protocols:
- type: mongodb
  send_request: true
  send_response: true
  max_docs: 0
  max_doc_length: 0
------------------------------------------------------------------------------

==== Configuration options

The `max_docs` and `max_doc_length` settings are useful for limiting the amount
of data Packetbeat indexes in the `response` fields.

Also see <<common-protocol-options>>.

===== `max_docs`

The maximum number of documents from the response to index in the `response` field. The
default is 10. You can set this to 0 to index an unlimited number of documents.

Packetbeat adds a `[...]` line at the end to signify that there were additional documents
that weren't saved because of this setting.

===== `max_doc_length`

The maximum number of characters in a single document indexed in the `response`
field. The default is 5000. You can set this to 0 to index an unlimited number
of characters per document.

If the document is trimmed because of this setting, Packetbeat adds the string `...`
at the end of the document.

Note that limiting documents in this way means that they are no longer correctly
formatted JSON objects.

[[configuration-tls]]
=== Capture TLS traffic

++++
<titleabbrev>TLS</titleabbrev>
++++

TLS is a cryptographic protocol that provides secure communications on top of
an existing application protocol, like HTTP or MySQL.

Packetbeat intercepts the initial handshake in a TLS connection and extracts
useful information that helps operators diagnose problems and
strengthen the security of their network and systems. It does not
decrypt any information from the encapsulated protocol, nor does it reveal any
sensitive information such as cryptographic keys. TLS versions 1.0 to 1.3 and
SSL 3.0 are supported.

It works by intercepting the client and server ""hello"" messages, which contain
the negotiated parameters for the connection such as cryptographic ciphers and
protocol versions. It can also intercept TLS alerts, which are sent by one
of the parties to signal a problem with the negotiation, such as an expired
certificate or a cryptographic error.

An example of indexed event:

[source,json]
------------------------------------------------------------------------------
""tls"": {
    ""client"": {
      ""supported_ciphers"": [
        ""TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"",
        ""TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"",
        ""TLS_RSA_WITH_3DES_EDE_CBC_SHA"",
        ""TLS_EMPTY_RENEGOTIATION_INFO_SCSV""
      ],
      ""ja3"": ""e6573e91e6eb777c0933c5b8f97f10cd"",
      ""server_name"": ""example.net""
    },
    ""server"": {
      ""subject"": ""CN=www.example.org,OU=Technology,O=Internet Corporation for Assigned Names and Numbers,L=Los Angeles,ST=California,C=US"",
      ""issuer"": ""CN=DigiCert SHA2 Secure Server CA,O=DigiCert Inc,C=US"",
      ""not_before"": ""2018-11-28T00:00:00.000Z"",
      ""not_after"": ""2020-12-02T12:00:00.000Z"",
      ""hash"": {
        ""sha1"": ""7BB698386970363D2919CC5772846984FFD4A889""
      }
    },
    ""version"": ""1.2"",
    ""version_protocol"": ""tls"",
    ""cipher"": ""TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"",
    ""established"": true,
    ""next_protocol"": ""h2"",
    ""detailed"": {
      ""server_certificate"": {
        ""subject"": {
          ""common_name"": ""www.example.org"",
          ""country"": ""US"",
          ""organization"": ""Internet Corporation for Assigned Names and Numbers"",
          ""organizational_unit"": ""Technology"",
          ""locality"": ""Los Angeles"",
          ""province"": ""California""
        },
        ""not_after"": ""2020-12-02T12:00:00.000Z"",
        ""public_key_size"": 2048,
        ""alternative_names"": [
          ""www.example.org"",
          ""example.com"",
          ""example.edu"",
          ""example.net"",
          ""example.org"",
          ""www.example.com"",
          ""www.example.edu"",
          ""www.example.net""
        ],
        ""signature_algorithm"": ""SHA256-RSA"",
        ""version"": 3,
        ""issuer"": {
          ""organization"": ""DigiCert Inc"",
          ""common_name"": ""DigiCert SHA2 Secure Server CA"",
          ""country"": ""US""
        },
        ""not_before"": ""2018-11-28T00:00:00.000Z"",
        ""public_key_algorithm"": ""RSA"",
        ""serial_number"": ""21020869104500376438182461249190639870""
      },
      ""server_certificate_chain"": [
        {
          ""public_key_algorithm"": ""RSA"",
          ""not_before"": ""2013-03-08T12:00:00.000Z"",
          ""not_after"": ""2023-03-08T12:00:00.000Z"",
          ""version"": 3,
          ""serial_number"": ""2646203786665923649276728595390119057"",
          ""issuer"": {
            ""organizational_unit"": ""www.digicert.com"",
            ""common_name"": ""DigiCert Global Root CA"",
            ""country"": ""US"",
            ""organization"": ""DigiCert Inc""
          },
          ""subject"": {
            ""country"": ""US"",
            ""organization"": ""DigiCert Inc"",
            ""common_name"": ""DigiCert SHA2 Secure Server CA""
          },
          ""public_key_size"": 2048,
          ""signature_algorithm"": ""SHA256-RSA""
        },
        {
          ""public_key_algorithm"": ""RSA"",
          ""subject"": {
            ""common_name"": ""DigiCert Global Root CA"",
            ""country"": ""US"",
            ""organization"": ""DigiCert Inc"",
            ""organizational_unit"": ""www.digicert.com""
          },
          ""issuer"": {
            ""country"": ""US"",
            ""organization"": ""DigiCert Inc"",
            ""organizational_unit"": ""www.digicert.com"",
            ""common_name"": ""DigiCert Global Root CA""
          },
          ""signature_algorithm"": ""SHA1-RSA"",
          ""serial_number"": ""10944719598952040374951832963794454346"",
          ""not_before"": ""2006-11-10T00:00:00.000Z"",
          ""not_after"": ""2031-11-10T00:00:00.000Z"",
          ""public_key_size"": 2048,
          ""version"": 3
        }
      ],
      ""client_certificate_requested"": false,
      ""version"": ""TLS 1.2"",
      ""client_hello"": {
        ""version"": ""3.3"",
        ""supported_compression_methods"": [
          ""NULL""
        ],
        ""extensions"": {
          ""ec_points_formats"": [
            ""uncompressed""
          ],
          ""supported_groups"": [
            ""x25519"",
            ""secp256r1"",
            ""secp384r1""
          ],
          ""signature_algorithms"": [
            ""rsa_pkcs1_sha512"",
            ""ecdsa_secp521r1_sha512"",
            ""(unknown:0xefef)"",
            ""rsa_pkcs1_sha384"",
            ""ecdsa_secp384r1_sha384"",
            ""rsa_pkcs1_sha256"",
            ""ecdsa_secp256r1_sha256"",
            ""(unknown:0xeeee)"",
            ""(unknown:0xeded)"",
            ""(unknown:0x0301)"",
            ""(unknown:0x0303)"",
            ""rsa_pkcs1_sha1"",
            ""ecdsa_sha1""
          ],
          ""application_layer_protocol_negotiation"": [
            ""h2"",
            ""http/1.1""
          ],
          ""server_name_indication"": [
            ""example.net""
          ]
        }
      },
      ""server_hello"": {
        ""version"": ""3.3"",
        ""session_id"": ""23bb2aed5d215e1228220b0a51d7aa220785e9e4b83b4f430229117971e9913f"",
        ""selected_compression_method"": ""NULL"",
        ""extensions"": {
          ""application_layer_protocol_negotiation"": [
            ""h2""
          ],
          ""_unparsed_"": [
            ""renegotiation_info"",
            ""server_name_indication""
          ],
          ""ec_points_formats"": [
            ""uncompressed"",
            ""ansiX962_compressed_prime"",
            ""ansiX962_compressed_char2""
          ]
        }
      }
    }
  }
------------------------------------------------------------------------------

The TLS events generated by {beatname_uc} follow the Elastic Common Schema
(ECS) format. See {ecs-ref}/ecs-tls.html[ECS TLS fields] for a description
of the populated fields.

Detailed information that is not defined in ECS is added under the
`tls.detailed` key. The <<include_detailed_fields>> configuration flag is used
to control whether this information is exported.

The fields under `tls.detailed.client_hello` contain the algorithms and
extensions supported by the client, as well as the maximum TLS version
it supports.

Fields under `tls.detailed.server_hello` contain the final settings for the TLS
session: The selected cipher, compression method, TLS version to use and
other extensions such as application layer protocol negotiation (ALPN).

See the <<exported-fields-tls_detailed>> section for more information.

The following settings are specific to the TLS protocol. Here is a sample
configuration for the `tls` section of the +{beatname_lc}.yml+ config file:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.protocols:
- type: tls
  send_certificates: true
  include_raw_certificates: false
  include_detailed_fields: true
  fingerprints: [ md5, sha1, sha256 ]
------------------------------------------------------------------------------

==== Configuration options

The `send_certificates` and `include_detailed_fields` settings are useful for
limiting the amount of data Packetbeat indexes, as multiple certificates are
usually exchanged in a single transaction, and those can take a considerable
amount of storage.

Also see <<common-protocol-options>>.

===== `send_certificates`

This setting causes information about the certificates presented by the
client and server to be included in the detailed fields. The server's
certificate is indexed under `tls.detailed.server_certificate` and its
certification chain under `tls.detailed.server_certificate_chain`.
For the client, the `client_certificate` and `client_certificate_chain` fields
are used. The default is true.

===== `include_raw_certificates`

You can set `include_raw_certificates` to include the raw certificate chains
encoded in PEM format, under the `tls.server.certificate_chain` and
`tls.client.certificate_chain` fields. The default is false.

[[include_detailed_fields]]
===== `include_detailed_fields`

Controls whether the <<exported-fields-tls_detailed>> are added to exported
documents. When set to `false`, only {ecs-ref}/ecs-tls.html[ECS TLS fields]
are included. The default is `true`.

===== `fingerprints`

Defines a list of hash algorithms to calculate the certificate's fingerprints.
Valid values are `sha1`, `sha256` and `md5`.

The default is to output SHA-1 fingerprints.

[[packetbeat-redis-options]]
=== Capture Redis traffic

++++
<titleabbrev>Redis</titleabbrev>
++++

The Redis protocol has several specific configuration options. Here is a
sample configuration for the `redis` section of the +{beatname_lc}.yml+ config file:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.protocols:
- type: redis
  ports: [6379]
  queue_max_bytes: 1048576
  queue_max_messages: 20000
------------------------------------------------------------------------------

==== Configuration options

Also see <<common-protocol-options>>.

===== `queue_max_bytes` and `queue_max_messages`

In order for request/response correlation to work, {beatname_uc} needs to
store requests in memory until a response is received. These settings impose
a limit on the number of bytes (`queue_max_bytes`) and number of requests
(`queue_max_messages`) that can be stored. These limits are per-connection.
The default is to queue up to 1MB or 20.000 requests per connection, which
allows to use request pipelining while at the same time limiting the amount
of memory consumed by replication sessions.

[[configuration-processes]]
== Specify which processes to monitor

This section of the +{beatname_lc}.yml+ config file is optional, but configuring
the processes enables Packetbeat to show you not only the servers that the
traffic is flowing between, but also the processes. Packetbeat can even show you
the traffic between two processes running on the same host, which is
particularly useful when you have many services running on the same server. By
default, process enrichment is disabled.

When Packetbeat starts, and then periodically afterwards, it scans the process
table for processes that match the configuration file. For each of these
processes, it monitors which file descriptors it has opened. When a new packet
is captured, it reads the list of active TCP and UDP connections and matches the
corresponding one with the list of file descriptors.

All this information is available via system interfaces: The `/proc` file system
in Linux and the IP Helper API (`iphlpapi.dll`) on Windows, so {beatname_uc}
doesn't need a kernel module.

NOTE: Process monitoring is currently only supported on
      Linux and Windows systems. Packetbeat automatically disables
      process monitoring when it detects other operating systems.

Example configuration:

[source,yaml]
------------------------------------------------------------------------------
packetbeat.procs.enabled: true
------------------------------------------------------------------------------

When the process monitor is enabled, it will enrich all the events whose source
or destination is a local process. The `source.process` and/or
`destination.process` fields will be added to an event, when the server side or
client side of the connection belong to a local process, respectively.

[float]
=== Configuration options

You can specify the following process monitoring options in the `monitored`
section of the +{beatname_lc}.yml+ config file to customize the name of process:

[float]
==== `process`

The name of the process as it will appear in the published transactions. The name
doesn't have to match the name of the executable, so feel free to choose something
more descriptive (for example,  ""myapp"" instead of ""gunicorn"").

[float]
==== `cmdline_grep`

The name used to identify the process at run time. When Packetbeat starts, and then
periodically afterwards, it scans the process table for
processes that match the values specified for this option. The match is done against the
process' command line as read from `/proc/<pid>/cmdline`.


[float]
[[shutdown-timeout]]
==== `shutdown_timeout`

How long Packetbeat waits on shutdown. By default, this option is disabled. Packetbeat
will wait for `shutdown_timeout` and then close. It will not track if all events were sent
previously.

Example configuration:

[source,yaml]
-------------------------------------------------------------------------------------
packetbeat.shutdown_timeout: 5s
-------------------------------------------------------------------------------------
",12211,False,2111.5194654830534,median
"/**
* This file is part of ORB-SLAM2.
* This file is based on the file orb.cpp from the OpenCV library (see BSD license below).
*
* Copyright (C) 2014-2016 Raúl Mur-Artal <raulmur at unizar dot es> (University of Zaragoza)
* For more information see <https://github.com/raulmur/ORB_SLAM2>
*
* ORB-SLAM2 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 3 of the License, or
* (at your option) any later version.
*
* ORB-SLAM2 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 ORB-SLAM2. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* Software License Agreement (BSD License)
*
*  Copyright (c) 2009, Willow Garage, Inc.
*  All rights reserved.
*
*  Redistribution and use in source and binary forms, with or without
*  modification, are permitted provided that the following conditions
*  are met:
*
*   * Redistributions of source code must retain the above copyright
*     notice, this list of conditions and the following disclaimer.
*   * Redistributions in binary form must reproduce the above
*     copyright notice, this list of conditions and the following
*     disclaimer in the documentation and/or other materials provided
*     with the distribution.
*   * Neither the name of the Willow Garage nor the names of its
*     contributors may be used to endorse or promote products derived
*     from this software without specific prior written permission.
*
*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
*  ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
*  POSSIBILITY OF SUCH DAMAGE.
*
*/


#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/features2d/features2d.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <vector>

#include ""liborbslam/ORBextractor.h""


using namespace cv;
using namespace std;

namespace ORB_SLAM2
{

const int PATCH_SIZE = 31;
const int HALF_PATCH_SIZE = 15;
const int EDGE_THRESHOLD = 19;


static float IC_Angle(const Mat& image, Point2f pt,  const vector<int> & u_max)
{
    int m_01 = 0, m_10 = 0;

    const uchar* center = &image.at<uchar> (cvRound(pt.y), cvRound(pt.x));

    // Treat the center line differently, v=0
    for (int u = -HALF_PATCH_SIZE; u <= HALF_PATCH_SIZE; ++u)
        m_10 += u * center[u];

    // Go line by line in the circuI853lar patch
    int step = (int)image.step1();
    for (int v = 1; v <= HALF_PATCH_SIZE; ++v)
    {
        // Proceed over the two lines
        int v_sum = 0;
        int d = u_max[v];
        for (int u = -d; u <= d; ++u)
        {
            int val_plus = center[u + v*step], val_minus = center[u - v*step];
            v_sum += (val_plus - val_minus);
            m_10 += u * (val_plus + val_minus);
        }
        m_01 += v * v_sum;
    }

    return fastAtan2((float)m_01, (float)m_10);
}


const float factorPI = (float)(CV_PI/180.f);
static void computeOrbDescriptor(const KeyPoint& kpt,
                                 const Mat& img, const Point* pattern,
                                 uchar* desc)
{
    float angle = (float)kpt.angle*factorPI;
    float a = (float)cos(angle), b = (float)sin(angle);

    const uchar* center = &img.at<uchar>(cvRound(kpt.pt.y), cvRound(kpt.pt.x));
    const int step = (int)img.step;

    #define GET_VALUE(idx) \\
        center[cvRound(pattern[idx].x*b + pattern[idx].y*a)*step + \\
               cvRound(pattern[idx].x*a - pattern[idx].y*b)]


    for (int i = 0; i < 32; ++i, pattern += 16)
    {
        int t0, t1, val;
        t0 = GET_VALUE(0); t1 = GET_VALUE(1);
        val = t0 < t1;
        t0 = GET_VALUE(2); t1 = GET_VALUE(3);
        val |= (t0 < t1) << 1;
        t0 = GET_VALUE(4); t1 = GET_VALUE(5);
        val |= (t0 < t1) << 2;
        t0 = GET_VALUE(6); t1 = GET_VALUE(7);
        val |= (t0 < t1) << 3;
        t0 = GET_VALUE(8); t1 = GET_VALUE(9);
        val |= (t0 < t1) << 4;
        t0 = GET_VALUE(10); t1 = GET_VALUE(11);
        val |= (t0 < t1) << 5;
        t0 = GET_VALUE(12); t1 = GET_VALUE(13);
        val |= (t0 < t1) << 6;
        t0 = GET_VALUE(14); t1 = GET_VALUE(15);
        val |= (t0 < t1) << 7;

        desc[i] = (uchar)val;
    }

    #undef GET_VALUE
}


static int bit_pattern_31_[256*4] =
{
    8,-3, 9,5/*mean (0), correlation (0)*/,
    4,2, 7,-12/*mean (1.12461e-05), correlation (0.0437584)*/,
    -11,9, -8,2/*mean (3.37382e-05), correlation (0.0617409)*/,
    7,-12, 12,-13/*mean (5.62303e-05), correlation (0.0636977)*/,
    2,-13, 2,12/*mean (0.000134953), correlation (0.085099)*/,
    1,-7, 1,6/*mean (0.000528565), correlation (0.0857175)*/,
    -2,-10, -2,-4/*mean (0.0188821), correlation (0.0985774)*/,
    -13,-13, -11,-8/*mean (0.0363135), correlation (0.0899616)*/,
    -13,-3, -12,-9/*mean (0.121806), correlation (0.099849)*/,
    10,4, 11,9/*mean (0.122065), correlation (0.093285)*/,
    -13,-8, -8,-9/*mean (0.162787), correlation (0.0942748)*/,
    -11,7, -9,12/*mean (0.21561), correlation (0.0974438)*/,
    7,7, 12,6/*mean (0.160583), correlation (0.130064)*/,
    -4,-5, -3,0/*mean (0.228171), correlation (0.132998)*/,
    -13,2, -12,-3/*mean (0.00997526), correlation (0.145926)*/,
    -9,0, -7,5/*mean (0.198234), correlation (0.143636)*/,
    12,-6, 12,-1/*mean (0.0676226), correlation (0.16689)*/,
    -3,6, -2,12/*mean (0.166847), correlation (0.171682)*/,
    -6,-13, -4,-8/*mean (0.101215), correlation (0.179716)*/,
    11,-13, 12,-8/*mean (0.200641), correlation (0.192279)*/,
    4,7, 5,1/*mean (0.205106), correlation (0.186848)*/,
    5,-3, 10,-3/*mean (0.234908), correlation (0.192319)*/,
    3,-7, 6,12/*mean (0.0709964), correlation (0.210872)*/,
    -8,-7, -6,-2/*mean (0.0939834), correlation (0.212589)*/,
    -2,11, -1,-10/*mean (0.127778), correlation (0.20866)*/,
    -13,12, -8,10/*mean (0.14783), correlation (0.206356)*/,
    -7,3, -5,-3/*mean (0.182141), correlation (0.198942)*/,
    -4,2, -3,7/*mean (0.188237), correlation (0.21384)*/,
    -10,-12, -6,11/*mean (0.14865), correlation (0.23571)*/,
    5,-12, 6,-7/*mean (0.222312), correlation (0.23324)*/,
    5,-6, 7,-1/*mean (0.229082), correlation (0.23389)*/,
    1,0, 4,-5/*mean (0.241577), correlation (0.215286)*/,
    9,11, 11,-13/*mean (0.00338507), correlation (0.251373)*/,
    4,7, 4,12/*mean (0.131005), correlation (0.257622)*/,
    2,-1, 4,4/*mean (0.152755), correlation (0.255205)*/,
    -4,-12, -2,7/*mean (0.182771), correlation (0.244867)*/,
    -8,-5, -7,-10/*mean (0.186898), correlation (0.23901)*/,
    4,11, 9,12/*mean (0.226226), correlation (0.258255)*/,
    0,-8, 1,-13/*mean (0.0897886), correlation (0.274827)*/,
    -13,-2, -8,2/*mean (0.148774), correlation (0.28065)*/,
    -3,-2, -2,3/*mean (0.153048), correlation (0.283063)*/,
    -6,9, -4,-9/*mean (0.169523), correlation (0.278248)*/,
    8,12, 10,7/*mean (0.225337), correlation (0.282851)*/,
    0,9, 1,3/*mean (0.226687), correlation (0.278734)*/,
    7,-5, 11,-10/*mean (0.00693882), correlation (0.305161)*/,
    -13,-6, -11,0/*mean (0.0227283), correlation (0.300181)*/,
    10,7, 12,1/*mean (0.125517), correlation (0.31089)*/,
    -6,-3, -6,12/*mean (0.131748), correlation (0.312779)*/,
    10,-9, 12,-4/*mean (0.144827), correlation (0.292797)*/,
    -13,8, -8,-12/*mean (0.149202), correlation (0.308918)*/,
    -13,0, -8,-4/*mean (0.160909), correlation (0.310013)*/,
    3,3, 7,8/*mean (0.177755), correlation (0.309394)*/,
    5,7, 10,-7/*mean (0.212337), correlation (0.310315)*/,
    -1,7, 1,-12/*mean (0.214429), correlation (0.311933)*/,
    3,-10, 5,6/*mean (0.235807), correlation (0.313104)*/,
    2,-4, 3,-10/*mean (0.00494827), correlation (0.344948)*/,
    -13,0, -13,5/*mean (0.0549145), correlation (0.344675)*/,
    -13,-7, -12,12/*mean (0.103385), correlation (0.342715)*/,
    -13,3, -11,8/*mean (0.134222), correlation (0.322922)*/,
    -7,12, -4,7/*mean (0.153284), correlation (0.337061)*/,
    6,-10, 12,8/*mean (0.154881), correlation (0.329257)*/,
    -9,-1, -7,-6/*mean (0.200967), correlation (0.33312)*/,
    -2,-5, 0,12/*mean (0.201518), correlation (0.340635)*/,
    -12,5, -7,5/*mean (0.207805), correlation (0.335631)*/,
    3,-10, 8,-13/*mean (0.224438), correlation (0.34504)*/,
    -7,-7, -4,5/*mean (0.239361), correlation (0.338053)*/,
    -3,-2, -1,-7/*mean (0.240744), correlation (0.344322)*/,
    2,9, 5,-11/*mean (0.242949), correlation (0.34145)*/,
    -11,-13, -5,-13/*mean (0.244028), correlation (0.336861)*/,
    -1,6, 0,-1/*mean (0.247571), correlation (0.343684)*/,
    5,-3, 5,2/*mean (0.000697256), correlation (0.357265)*/,
    -4,-13, -4,12/*mean (0.00213675), correlation (0.373827)*/,
    -9,-6, -9,6/*mean (0.0126856), correlation (0.373938)*/,
    -12,-10, -8,-4/*mean (0.0152497), correlation (0.364237)*/,
    10,2, 12,-3/*mean (0.0299933), correlation (0.345292)*/,
    7,12, 12,12/*mean (0.0307242), correlation (0.366299)*/,
    -7,-13, -6,5/*mean (0.0534975), correlation (0.368357)*/,
    -4,9, -3,4/*mean (0.099865), correlation (0.372276)*/,
    7,-1, 12,2/*mean (0.117083), correlation (0.364529)*/,
    -7,6, -5,1/*mean (0.126125), correlation (0.369606)*/,
    -13,11, -12,5/*mean (0.130364), correlation (0.358502)*/,
    -3,7, -2,-6/*mean (0.131691), correlation (0.375531)*/,
    7,-8, 12,-7/*mean (0.160166), correlation (0.379508)*/,
    -13,-7, -11,-12/*mean (0.167848), correlation (0.353343)*/,
    1,-3, 12,12/*mean (0.183378), correlation (0.371916)*/,
    2,-6, 3,0/*mean (0.228711), correlation (0.371761)*/,
    -4,3, -2,-13/*mean (0.247211), correlation (0.364063)*/,
    -1,-13, 1,9/*mean (0.249325), correlation (0.378139)*/,
    7,1, 8,-6/*mean (0.000652272), correlation (0.411682)*/,
    1,-1, 3,12/*mean (0.00248538), correlation (0.392988)*/,
    9,1, 12,6/*mean (0.0206815), correlation (0.386106)*/,
    -1,-9, -1,3/*mean (0.0364485), correlation (0.410752)*/,
    -13,-13, -10,5/*mean (0.0376068), correlation (0.398374)*/,
    7,7, 10,12/*mean (0.0424202), correlation (0.405663)*/,
    12,-5, 12,9/*mean (0.0942645), correlation (0.410422)*/,
    6,3, 7,11/*mean (0.1074), correlation (0.413224)*/,
    5,-13, 6,10/*mean (0.109256), correlation (0.408646)*/,
    2,-12, 2,3/*mean (0.131691), correlation (0.416076)*/,
    3,8, 4,-6/*mean (0.165081), correlation (0.417569)*/,
    2,6, 12,-13/*mean (0.171874), correlation (0.408471)*/,
    9,-12, 10,3/*mean (0.175146), correlation (0.41296)*/,
    -8,4, -7,9/*mean (0.183682), correlation (0.402956)*/,
    -11,12, -4,-6/*mean (0.184672), correlation (0.416125)*/,
    1,12, 2,-8/*mean (0.191487), correlation (0.386696)*/,
    6,-9, 7,-4/*mean (0.192668), correlation (0.394771)*/,
    2,3, 3,-2/*mean (0.200157), correlation (0.408303)*/,
    6,3, 11,0/*mean (0.204588), correlation (0.411762)*/,
    3,-3, 8,-8/*mean (0.205904), correlation (0.416294)*/,
    7,8, 9,3/*mean (0.213237), correlation (0.409306)*/,
    -11,-5, -6,-4/*mean (0.243444), correlation (0.395069)*/,
    -10,11, -5,10/*mean (0.247672), correlation (0.413392)*/,
    -5,-8, -3,12/*mean (0.24774), correlation (0.411416)*/,
    -10,5, -9,0/*mean (0.00213675), correlation (0.454003)*/,
    8,-1, 12,-6/*mean (0.0293635), correlation (0.455368)*/,
    4,-6, 6,-11/*mean (0.0404971), correlation (0.457393)*/,
    -10,12, -8,7/*mean (0.0481107), correlation (0.448364)*/,
    4,-2, 6,7/*mean (0.050641), correlation (0.455019)*/,
    -2,0, -2,12/*mean (0.0525978), correlation (0.44338)*/,
    -5,-8, -5,2/*mean (0.0629667), correlation (0.457096)*/,
    7,-6, 10,12/*mean (0.0653846), correlation (0.445623)*/,
    -9,-13, -8,-8/*mean (0.0858749), correlation (0.449789)*/,
    -5,-13, -5,-2/*mean (0.122402), correlation (0.450201)*/,
    8,-8, 9,-13/*mean (0.125416), correlation (0.453224)*/,
    -9,-11, -9,0/*mean (0.130128), correlation (0.458724)*/,
    1,-8, 1,-2/*mean (0.132467), correlation (0.440133)*/,
    7,-4, 9,1/*mean (0.132692), correlation (0.454)*/,
    -2,1, -1,-4/*mean (0.135695), correlation (0.455739)*/,
    11,-6, 12,-11/*mean (0.142904), correlation (0.446114)*/,
    -12,-9, -6,4/*mean (0.146165), correlation (0.451473)*/,
    3,7, 7,12/*mean (0.147627), correlation (0.456643)*/,
    5,5, 10,8/*mean (0.152901), correlation (0.455036)*/,
    0,-4, 2,8/*mean (0.167083), correlation (0.459315)*/,
    -9,12, -5,-13/*mean (0.173234), correlation (0.454706)*/,
    0,7, 2,12/*mean (0.18312), correlation (0.433855)*/,
    -1,2, 1,7/*mean (0.185504), correlation (0.443838)*/,
    5,11, 7,-9/*mean (0.185706), correlation (0.451123)*/,
    3,5, 6,-8/*mean (0.188968), correlation (0.455808)*/,
    -13,-4, -8,9/*mean (0.191667), correlation (0.459128)*/,
    -5,9, -3,-3/*mean (0.193196), correlation (0.458364)*/,
    -4,-7, -3,-12/*mean (0.196536), correlation (0.455782)*/,
    6,5, 8,0/*mean (0.1972), correlation (0.450481)*/,
    -7,6, -6,12/*mean (0.199438), correlation (0.458156)*/,
    -13,6, -5,-2/*mean (0.211224), correlation (0.449548)*/,
    1,-10, 3,10/*mean (0.211718), correlation (0.440606)*/,
    4,1, 8,-4/*mean (0.213034), correlation (0.443177)*/,
    -2,-2, 2,-13/*mean (0.234334), correlation (0.455304)*/,
    2,-12, 12,12/*mean (0.235684), correlation (0.443436)*/,
    -2,-13, 0,-6/*mean (0.237674), correlation (0.452525)*/,
    4,1, 9,3/*mean (0.23962), correlation (0.444824)*/,
    -6,-10, -3,-5/*mean (0.248459), correlation (0.439621)*/,
    -3,-13, -1,1/*mean (0.249505), correlation (0.456666)*/,
    7,5, 12,-11/*mean (0.00119208), correlation (0.495466)*/,
    4,-2, 5,-7/*mean (0.00372245), correlation (0.484214)*/,
    -13,9, -9,-5/*mean (0.00741116), correlation (0.499854)*/,
    7,1, 8,6/*mean (0.0208952), correlation (0.499773)*/,
    7,-8, 7,6/*mean (0.0220085), correlation (0.501609)*/,
    -7,-4, -7,1/*mean (0.0233806), correlation (0.496568)*/,
    -8,11, -7,-8/*mean (0.0236505), correlation (0.489719)*/,
    -13,6, -12,-8/*mean (0.0268781), correlation (0.503487)*/,
    2,4, 3,9/*mean (0.0323324), correlation (0.501938)*/,
    10,-5, 12,3/*mean (0.0399235), correlation (0.494029)*/,
    -6,-5, -6,7/*mean (0.0420153), correlation (0.486579)*/,
    8,-3, 9,-8/*mean (0.0548021), correlation (0.484237)*/,
    2,-12, 2,8/*mean (0.0616622), correlation (0.496642)*/,
    -11,-2, -10,3/*mean (0.0627755), correlation (0.498563)*/,
    -12,-13, -7,-9/*mean (0.0829622), correlation (0.495491)*/,
    -11,0, -10,-5/*mean (0.0843342), correlation (0.487146)*/,
    5,-3, 11,8/*mean (0.0929937), correlation (0.502315)*/,
    -2,-13, -1,12/*mean (0.113327), correlation (0.48941)*/,
    -1,-8, 0,9/*mean (0.132119), correlation (0.467268)*/,
    -13,-11, -12,-5/*mean (0.136269), correlation (0.498771)*/,
    -10,-2, -10,11/*mean (0.142173), correlation (0.498714)*/,
    -3,9, -2,-13/*mean (0.144141), correlation (0.491973)*/,
    2,-3, 3,2/*mean (0.14892), correlation (0.500782)*/,
    -9,-13, -4,0/*mean (0.150371), correlation (0.498211)*/,
    -4,6, -3,-10/*mean (0.152159), correlation (0.495547)*/,
    -4,12, -2,-7/*mean (0.156152), correlation (0.496925)*/,
    -6,-11, -4,9/*mean (0.15749), correlation (0.499222)*/,
    6,-3, 6,11/*mean (0.159211), correlation (0.503821)*/,
    -13,11, -5,5/*mean (0.162427), correlation (0.501907)*/,
    11,11, 12,6/*mean (0.16652), correlation (0.497632)*/,
    7,-5, 12,-2/*mean (0.169141), correlation (0.484474)*/,
    -1,12, 0,7/*mean (0.169456), correlation (0.495339)*/,
    -4,-8, -3,-2/*mean (0.171457), correlation (0.487251)*/,
    -7,1, -6,7/*mean (0.175), correlation (0.500024)*/,
    -13,-12, -8,-13/*mean (0.175866), correlation (0.497523)*/,
    -7,-2, -6,-8/*mean (0.178273), correlation (0.501854)*/,
    -8,5, -6,-9/*mean (0.181107), correlation (0.494888)*/,
    -5,-1, -4,5/*mean (0.190227), correlation (0.482557)*/,
    -13,7, -8,10/*mean (0.196739), correlation (0.496503)*/,
    1,5, 5,-13/*mean (0.19973), correlation (0.499759)*/,
    1,0, 10,-13/*mean (0.204465), correlation (0.49873)*/,
    9,12, 10,-1/*mean (0.209334), correlation (0.49063)*/,
    5,-8, 10,-9/*mean (0.211134), correlation (0.503011)*/,
    -1,11, 1,-13/*mean (0.212), correlation (0.499414)*/,
    -9,-3, -6,2/*mean (0.212168), correlation (0.480739)*/,
    -1,-10, 1,12/*mean (0.212731), correlation (0.502523)*/,
    -13,1, -8,-10/*mean (0.21327), correlation (0.489786)*/,
    8,-11, 10,-6/*mean (0.214159), correlation (0.488246)*/,
    2,-13, 3,-6/*mean (0.216993), correlation (0.50287)*/,
    7,-13, 12,-9/*mean (0.223639), correlation (0.470502)*/,
    -10,-10, -5,-7/*mean (0.224089), correlation (0.500852)*/,
    -10,-8, -8,-13/*mean (0.228666), correlation (0.502629)*/,
    4,-6, 8,5/*mean (0.22906), correlation (0.498305)*/,
    3,12, 8,-13/*mean (0.233378), correlation (0.503825)*/,
    -4,2, -3,-3/*mean (0.234323), correlation (0.476692)*/,
    5,-13, 10,-12/*mean (0.236392), correlation (0.475462)*/,
    4,-13, 5,-1/*mean (0.236842), correlation (0.504132)*/,
    -9,9, -4,3/*mean (0.236977), correlation (0.497739)*/,
    0,3, 3,-9/*mean (0.24314), correlation (0.499398)*/,
    -12,1, -6,1/*mean (0.243297), correlation (0.489447)*/,
    3,2, 4,-8/*mean (0.00155196), correlation (0.553496)*/,
    -10,-10, -10,9/*mean (0.00239541), correlation (0.54297)*/,
    8,-13, 12,12/*mean (0.0034413), correlation (0.544361)*/,
    -8,-12, -6,-5/*mean (0.003565), correlation (0.551225)*/,
    2,2, 3,7/*mean (0.00835583), correlation (0.55285)*/,
    10,6, 11,-8/*mean (0.00885065), correlation (0.540913)*/,
    6,8, 8,-12/*mean (0.0101552), correlation (0.551085)*/,
    -7,10, -6,5/*mean (0.0102227), correlation (0.533635)*/,
    -3,-9, -3,9/*mean (0.0110211), correlation (0.543121)*/,
    -1,-13, -1,5/*mean (0.0113473), correlation (0.550173)*/,
    -3,-7, -3,4/*mean (0.0140913), correlation (0.554774)*/,
    -8,-2, -8,3/*mean (0.017049), correlation (0.55461)*/,
    4,2, 12,12/*mean (0.01778), correlation (0.546921)*/,
    2,-5, 3,11/*mean (0.0224022), correlation (0.549667)*/,
    6,-9, 11,-13/*mean (0.029161), correlation (0.546295)*/,
    3,-1, 7,12/*mean (0.0303081), correlation (0.548599)*/,
    11,-1, 12,4/*mean (0.0355151), correlation (0.523943)*/,
    -3,0, -3,6/*mean (0.0417904), correlation (0.543395)*/,
    4,-11, 4,12/*mean (0.0487292), correlation (0.542818)*/,
    2,-4, 2,1/*mean (0.0575124), correlation (0.554888)*/,
    -10,-6, -8,1/*mean (0.0594242), correlation (0.544026)*/,
    -13,7, -11,1/*mean (0.0597391), correlation (0.550524)*/,
    -13,12, -11,-13/*mean (0.0608974), correlation (0.55383)*/,
    6,0, 11,-13/*mean (0.065126), correlation (0.552006)*/,
    0,-1, 1,4/*mean (0.074224), correlation (0.546372)*/,
    -13,3, -9,-2/*mean (0.0808592), correlation (0.554875)*/,
    -9,8, -6,-3/*mean (0.0883378), correlation (0.551178)*/,
    -13,-6, -8,-2/*mean (0.0901035), correlation (0.548446)*/,
    5,-9, 8,10/*mean (0.0949843), correlation (0.554694)*/,
    2,7, 3,-9/*mean (0.0994152), correlation (0.550979)*/,
    -1,-6, -1,-1/*mean (0.10045), correlation (0.552714)*/,
    9,5, 11,-2/*mean (0.100686), correlation (0.552594)*/,
    11,-3, 12,-8/*mean (0.101091), correlation (0.532394)*/,
    3,0, 3,5/*mean (0.101147), correlation (0.525576)*/,
    -1,4, 0,10/*mean (0.105263), correlation (0.531498)*/,
    3,-6, 4,5/*mean (0.110785), correlation (0.540491)*/,
    -13,0, -10,5/*mean (0.112798), correlation (0.536582)*/,
    5,8, 12,11/*mean (0.114181), correlation (0.555793)*/,
    8,9, 9,-6/*mean (0.117431), correlation (0.553763)*/,
    7,-4, 8,-12/*mean (0.118522), correlation (0.553452)*/,
    -10,4, -10,9/*mean (0.12094), correlation (0.554785)*/,
    7,3, 12,4/*mean (0.122582), correlation (0.555825)*/,
    9,-7, 10,-2/*mean (0.124978), correlation (0.549846)*/,
    7,0, 12,-2/*mean (0.127002), correlation (0.537452)*/,
    -1,-6, 0,-11/*mean (0.127148), correlation (0.547401)*/
};

ORBextractor::ORBextractor(int _nfeatures, float _scaleFactor, int _nlevels,
         int _iniThFAST, int _minThFAST):
    nfeatures(_nfeatures), scaleFactor(_scaleFactor), nlevels(_nlevels),
    iniThFAST(_iniThFAST), minThFAST(_minThFAST)
{
    mvScaleFactor.resize(nlevels);
    mvLevelSigma2.resize(nlevels);
    mvScaleFactor[0]=1.0f;
    mvLevelSigma2[0]=1.0f;
    for(int i=1; i<nlevels; i++)
    {
        mvScaleFactor[i]=mvScaleFactor[i-1]*scaleFactor;
        mvLevelSigma2[i]=mvScaleFactor[i]*mvScaleFactor[i];
    }

    mvInvScaleFactor.resize(nlevels);
    mvInvLevelSigma2.resize(nlevels);
    for(int i=0; i<nlevels; i++)
    {
        mvInvScaleFactor[i]=1.0f/mvScaleFactor[i];
        mvInvLevelSigma2[i]=1.0f/mvLevelSigma2[i];
    }

    mvImagePyramid.resize(nlevels);

    mnFeaturesPerLevel.resize(nlevels);
    float factor = 1.0f / scaleFactor;
    float nDesiredFeaturesPerScale = nfeatures*(1 - factor)/(1 - (float)pow((double)factor, (double)nlevels));

    int sumFeatures = 0;
    for( int level = 0; level < nlevels-1; level++ )
    {
        mnFeaturesPerLevel[level] = cvRound(nDesiredFeaturesPerScale);
        sumFeatures += mnFeaturesPerLevel[level];
        nDesiredFeaturesPerScale *= factor;
    }
    mnFeaturesPerLevel[nlevels-1] = std::max(nfeatures - sumFeatures, 0);

    const int npoints = 512;
    const Point* pattern0 = (const Point*)bit_pattern_31_;
    std::copy(pattern0, pattern0 + npoints, std::back_inserter(pattern));

    //This is for orientation
    // pre-compute the end of a row in a circular patch
    umax.resize(HALF_PATCH_SIZE + 1);

    int v, v0, vmax = cvFloor(HALF_PATCH_SIZE * sqrt(2.f) / 2 + 1);
    int vmin = cvCeil(HALF_PATCH_SIZE * sqrt(2.f) / 2);
    const double hp2 = HALF_PATCH_SIZE*HALF_PATCH_SIZE;
    for (v = 0; v <= vmax; ++v)
        umax[v] = cvRound(sqrt(hp2 - v * v));

    // Make sure we are symmetric
    for (v = HALF_PATCH_SIZE, v0 = 0; v >= vmin; --v)
    {
        while (umax[v0] == umax[v0 + 1])
            ++v0;
        umax[v] = v0;
        ++v0;
    }
}

static void computeOrientation(const Mat& image, vector<KeyPoint>& keypoints, const vector<int>& umax)
{
    for (vector<KeyPoint>::iterator keypoint = keypoints.begin(),
         keypointEnd = keypoints.end(); keypoint != keypointEnd; ++keypoint)
    {
        keypoint->angle = IC_Angle(image, keypoint->pt, umax);
    }
}

void ExtractorNode::DivideNode(ExtractorNode &n1, ExtractorNode &n2, ExtractorNode &n3, ExtractorNode &n4)
{
    const int halfX = ceil(static_cast<float>(UR.x-UL.x)/2);
    const int halfY = ceil(static_cast<float>(BR.y-UL.y)/2);

    //Define boundaries of childs
    n1.UL = UL;
    n1.UR = cv::Point2i(UL.x+halfX,UL.y);
    n1.BL = cv::Point2i(UL.x,UL.y+halfY);
    n1.BR = cv::Point2i(UL.x+halfX,UL.y+halfY);
    n1.vKeys.reserve(vKeys.size());

    n2.UL = n1.UR;
    n2.UR = UR;
    n2.BL = n1.BR;
    n2.BR = cv::Point2i(UR.x,UL.y+halfY);
    n2.vKeys.reserve(vKeys.size());

    n3.UL = n1.BL;
    n3.UR = n1.BR;
    n3.BL = BL;
    n3.BR = cv::Point2i(n1.BR.x,BL.y);
    n3.vKeys.reserve(vKeys.size());

    n4.UL = n3.UR;
    n4.UR = n2.BR;
    n4.BL = n3.BR;
    n4.BR = BR;
    n4.vKeys.reserve(vKeys.size());

    //Associate points to childs
    for(size_t i=0;i<vKeys.size();i++)
    {
        const cv::KeyPoint &kp = vKeys[i];
        if(kp.pt.x<n1.UR.x)
        {
            if(kp.pt.y<n1.BR.y)
                n1.vKeys.push_back(kp);
            else
                n3.vKeys.push_back(kp);
        }
        else if(kp.pt.y<n1.BR.y)
            n2.vKeys.push_back(kp);
        else
            n4.vKeys.push_back(kp);
    }

    if(n1.vKeys.size()==1)
        n1.bNoMore = true;
    if(n2.vKeys.size()==1)
        n2.bNoMore = true;
    if(n3.vKeys.size()==1)
        n3.bNoMore = true;
    if(n4.vKeys.size()==1)
        n4.bNoMore = true;

}

vector<cv::KeyPoint> ORBextractor::DistributeOctTree(const vector<cv::KeyPoint>& vToDistributeKeys, const int &minX,
                                       const int &maxX, const int &minY, const int &maxY, const int &N, const int &level)
{
    // Compute how many initial nodes   
    const int nIni = round(static_cast<float>(maxX-minX)/(maxY-minY));

    const float hX = static_cast<float>(maxX-minX)/nIni;

    list<ExtractorNode> lNodes;

    vector<ExtractorNode*> vpIniNodes;
    vpIniNodes.resize(nIni);

    for(int i=0; i<nIni; i++)
    {
        ExtractorNode ni;
        ni.UL = cv::Point2i(hX*static_cast<float>(i),0);
        ni.UR = cv::Point2i(hX*static_cast<float>(i+1),0);
        ni.BL = cv::Point2i(ni.UL.x,maxY-minY);
        ni.BR = cv::Point2i(ni.UR.x,maxY-minY);
        ni.vKeys.reserve(vToDistributeKeys.size());

        lNodes.push_back(ni);
        vpIniNodes[i] = &lNodes.back();
    }

    //Associate points to childs
    for(size_t i=0;i<vToDistributeKeys.size();i++)
    {
        const cv::KeyPoint &kp = vToDistributeKeys[i];
        vpIniNodes[kp.pt.x/hX]->vKeys.push_back(kp);
    }

    list<ExtractorNode>::iterator lit = lNodes.begin();

    while(lit!=lNodes.end())
    {
        if(lit->vKeys.size()==1)
        {
            lit->bNoMore=true;
            lit++;
        }
        else if(lit->vKeys.empty())
            lit = lNodes.erase(lit);
        else
            lit++;
    }

    bool bFinish = false;

    int iteration = 0;

    vector<pair<int,ExtractorNode*> > vSizeAndPointerToNode;
    vSizeAndPointerToNode.reserve(lNodes.size()*4);

    while(!bFinish)
    {
        iteration++;

        int prevSize = lNodes.size();

        lit = lNodes.begin();

        int nToExpand = 0;

        vSizeAndPointerToNode.clear();

        while(lit!=lNodes.end())
        {
            if(lit->bNoMore)
            {
                // If node only contains one point do not subdivide and continue
                lit++;
                continue;
            }
            else
            {
                // If more than one point, subdivide
                ExtractorNode n1,n2,n3,n4;
                lit->DivideNode(n1,n2,n3,n4);

                // Add childs if they contain points
                if(n1.vKeys.size()>0)
                {
                    lNodes.push_front(n1);                    
                    if(n1.vKeys.size()>1)
                    {
                        nToExpand++;
                        vSizeAndPointerToNode.push_back(make_pair(n1.vKeys.size(),&lNodes.front()));
                        lNodes.front().lit = lNodes.begin();
                    }
                }
                if(n2.vKeys.size()>0)
                {
                    lNodes.push_front(n2);
                    if(n2.vKeys.size()>1)
                    {
                        nToExpand++;
                        vSizeAndPointerToNode.push_back(make_pair(n2.vKeys.size(),&lNodes.front()));
                        lNodes.front().lit = lNodes.begin();
                    }
                }
                if(n3.vKeys.size()>0)
                {
                    lNodes.push_front(n3);
                    if(n3.vKeys.size()>1)
                    {
                        nToExpand++;
                        vSizeAndPointerToNode.push_back(make_pair(n3.vKeys.size(),&lNodes.front()));
                        lNodes.front().lit = lNodes.begin();
                    }
                }
                if(n4.vKeys.size()>0)
                {
                    lNodes.push_front(n4);
                    if(n4.vKeys.size()>1)
                    {
                        nToExpand++;
                        vSizeAndPointerToNode.push_back(make_pair(n4.vKeys.size(),&lNodes.front()));
                        lNodes.front().lit = lNodes.begin();
                    }
                }

                lit=lNodes.erase(lit);
                continue;
            }
        }       

        // Finish if there are more nodes than required features
        // or all nodes contain just one point
        if((int)lNodes.size()>=N || (int)lNodes.size()==prevSize)
        {
            bFinish = true;
        }
        else if(((int)lNodes.size()+nToExpand*3)>N)
        {

            while(!bFinish)
            {

                prevSize = lNodes.size();

                vector<pair<int,ExtractorNode*> > vPrevSizeAndPointerToNode = vSizeAndPointerToNode;
                vSizeAndPointerToNode.clear();

                sort(vPrevSizeAndPointerToNode.begin(),vPrevSizeAndPointerToNode.end());
                for(int j=vPrevSizeAndPointerToNode.size()-1;j>=0;j--)
                {
                    ExtractorNode n1,n2,n3,n4;
                    vPrevSizeAndPointerToNode[j].second->DivideNode(n1,n2,n3,n4);

                    // Add childs if they contain points
                    if(n1.vKeys.size()>0)
                    {
                        lNodes.push_front(n1);
                        if(n1.vKeys.size()>1)
                        {
                            vSizeAndPointerToNode.push_back(make_pair(n1.vKeys.size(),&lNodes.front()));
                            lNodes.front().lit = lNodes.begin();
                        }
                    }
                    if(n2.vKeys.size()>0)
                    {
                        lNodes.push_front(n2);
                        if(n2.vKeys.size()>1)
                        {
                            vSizeAndPointerToNode.push_back(make_pair(n2.vKeys.size(),&lNodes.front()));
                            lNodes.front().lit = lNodes.begin();
                        }
                    }
                    if(n3.vKeys.size()>0)
                    {
                        lNodes.push_front(n3);
                        if(n3.vKeys.size()>1)
                        {
                            vSizeAndPointerToNode.push_back(make_pair(n3.vKeys.size(),&lNodes.front()));
                            lNodes.front().lit = lNodes.begin();
                        }
                    }
                    if(n4.vKeys.size()>0)
                    {
                        lNodes.push_front(n4);
                        if(n4.vKeys.size()>1)
                        {
                            vSizeAndPointerToNode.push_back(make_pair(n4.vKeys.size(),&lNodes.front()));
                            lNodes.front().lit = lNodes.begin();
                        }
                    }

                    lNodes.erase(vPrevSizeAndPointerToNode[j].second->lit);

                    if((int)lNodes.size()>=N)
                        break;
                }

                if((int)lNodes.size()>=N || (int)lNodes.size()==prevSize)
                    bFinish = true;

            }
        }
    }

    // Retain the best point in each node
    vector<cv::KeyPoint> vResultKeys;
    vResultKeys.reserve(nfeatures);
    for(list<ExtractorNode>::iterator lit=lNodes.begin(); lit!=lNodes.end(); lit++)
    {
        vector<cv::KeyPoint> &vNodeKeys = lit->vKeys;
        cv::KeyPoint* pKP = &vNodeKeys[0];
        float maxResponse = pKP->response;

        for(size_t k=1;k<vNodeKeys.size();k++)
        {
            if(vNodeKeys[k].response>maxResponse)
            {
                pKP = &vNodeKeys[k];
                maxResponse = vNodeKeys[k].response;
            }
        }

        vResultKeys.push_back(*pKP);
    }

    return vResultKeys;
}

void ORBextractor::ComputeKeyPointsOctTree(vector<vector<KeyPoint> >& allKeypoints)
{
    allKeypoints.resize(nlevels);

    const float W = 30;

    for (int level = 0; level < nlevels; ++level)
    {
        const int minBorderX = EDGE_THRESHOLD-3;
        const int minBorderY = minBorderX;
        const int maxBorderX = mvImagePyramid[level].cols-EDGE_THRESHOLD+3;
        const int maxBorderY = mvImagePyramid[level].rows-EDGE_THRESHOLD+3;

        vector<cv::KeyPoint> vToDistributeKeys;
        vToDistributeKeys.reserve(nfeatures*10);

        const float width = (maxBorderX-minBorderX);
        const float height = (maxBorderY-minBorderY);

        const int nCols = width/W;
        const int nRows = height/W;
        const int wCell = ceil(width/nCols);
        const int hCell = ceil(height/nRows);

        for(int i=0; i<nRows; i++)
        {
            const float iniY =minBorderY+i*hCell;
            float maxY = iniY+hCell+6;

            if(iniY>=maxBorderY-3)
                continue;
            if(maxY>maxBorderY)
                maxY = maxBorderY;

            for(int j=0; j<nCols; j++)
            {
                const float iniX =minBorderX+j*wCell;
                float maxX = iniX+wCell+6;
                if(iniX>=maxBorderX-6)
                    continue;
                if(maxX>maxBorderX)
                    maxX = maxBorderX;

                vector<cv::KeyPoint> vKeysCell;
                FAST(mvImagePyramid[level].rowRange(iniY,maxY).colRange(iniX,maxX),
                     vKeysCell,iniThFAST,true);

                if(vKeysCell.empty())
                {
                    FAST(mvImagePyramid[level].rowRange(iniY,maxY).colRange(iniX,maxX),
                         vKeysCell,minThFAST,true);
                }

                if(!vKeysCell.empty())
                {
                    for(vector<cv::KeyPoint>::iterator vit=vKeysCell.begin(); vit!=vKeysCell.end();vit++)
                    {
                        (*vit).pt.x+=j*wCell;
                        (*vit).pt.y+=i*hCell;
                        vToDistributeKeys.push_back(*vit);
                    }
                }

            }
        }

        vector<KeyPoint> & keypoints = allKeypoints[level];
        keypoints.reserve(nfeatures);

        keypoints = DistributeOctTree(vToDistributeKeys, minBorderX, maxBorderX,
                                      minBorderY, maxBorderY,mnFeaturesPerLevel[level], level);

        const int scaledPatchSize = PATCH_SIZE*mvScaleFactor[level];

        // Add border to coordinates and scale information
        const int nkps = keypoints.size();
        for(int i=0; i<nkps ; i++)
        {
            keypoints[i].pt.x+=minBorderX;
            keypoints[i].pt.y+=minBorderY;
            keypoints[i].octave=level;
            keypoints[i].size = scaledPatchSize;
        }
    }

    // compute orientations
    for (int level = 0; level < nlevels; ++level)
        computeOrientation(mvImagePyramid[level], allKeypoints[level], umax);
}

void ORBextractor::ComputeKeyPointsOld(std::vector<std::vector<KeyPoint> > &allKeypoints)
{
    allKeypoints.resize(nlevels);

    float imageRatio = (float)mvImagePyramid[0].cols/mvImagePyramid[0].rows;

    for (int level = 0; level < nlevels; ++level)
    {
        const int nDesiredFeatures = mnFeaturesPerLevel[level];

        const int levelCols = sqrt((float)nDesiredFeatures/(5*imageRatio));
        const int levelRows = imageRatio*levelCols;

        const int minBorderX = EDGE_THRESHOLD;
        const int minBorderY = minBorderX;
        const int maxBorderX = mvImagePyramid[level].cols-EDGE_THRESHOLD;
        const int maxBorderY = mvImagePyramid[level].rows-EDGE_THRESHOLD;

        const int W = maxBorderX - minBorderX;
        const int H = maxBorderY - minBorderY;
        const int cellW = ceil((float)W/levelCols);
        const int cellH = ceil((float)H/levelRows);

        const int nCells = levelRows*levelCols;
        const int nfeaturesCell = ceil((float)nDesiredFeatures/nCells);

        vector<vector<vector<KeyPoint> > > cellKeyPoints(levelRows, vector<vector<KeyPoint> >(levelCols));

        vector<vector<int> > nToRetain(levelRows,vector<int>(levelCols,0));
        vector<vector<int> > nTotal(levelRows,vector<int>(levelCols,0));
        vector<vector<bool> > bNoMore(levelRows,vector<bool>(levelCols,false));
        vector<int> iniXCol(levelCols);
        vector<int> iniYRow(levelRows);
        int nNoMore = 0;
        int nToDistribute = 0;


        float hY = cellH + 6;

        for(int i=0; i<levelRows; i++)
        {
            const float iniY = minBorderY + i*cellH - 3;
            iniYRow[i] = iniY;

            if(i == levelRows-1)
            {
                hY = maxBorderY+3-iniY;
                if(hY<=0)
                    continue;
            }

            float hX = cellW + 6;

            for(int j=0; j<levelCols; j++)
            {
                float iniX;

                if(i==0)
                {
                    iniX = minBorderX + j*cellW - 3;
                    iniXCol[j] = iniX;
                }
                else
                {
                    iniX = iniXCol[j];
                }


                if(j == levelCols-1)
                {
                    hX = maxBorderX+3-iniX;
                    if(hX<=0)
                        continue;
                }


                Mat cellImage = mvImagePyramid[level].rowRange(iniY,iniY+hY).colRange(iniX,iniX+hX);

                cellKeyPoints[i][j].reserve(nfeaturesCell*5);

                FAST(cellImage,cellKeyPoints[i][j],iniThFAST,true);

                if(cellKeyPoints[i][j].size()<=3)
                {
                    cellKeyPoints[i][j].clear();

                    FAST(cellImage,cellKeyPoints[i][j],minThFAST,true);
                }


                const int nKeys = cellKeyPoints[i][j].size();
                nTotal[i][j] = nKeys;

                if(nKeys>nfeaturesCell)
                {
                    nToRetain[i][j] = nfeaturesCell;
                    bNoMore[i][j] = false;
                }
                else
                {
                    nToRetain[i][j] = nKeys;
                    nToDistribute += nfeaturesCell-nKeys;
                    bNoMore[i][j] = true;
                    nNoMore++;
                }

            }
        }


        // Retain by score

        while(nToDistribute>0 && nNoMore<nCells)
        {
            int nNewFeaturesCell = nfeaturesCell + ceil((float)nToDistribute/(nCells-nNoMore));
            nToDistribute = 0;

            for(int i=0; i<levelRows; i++)
            {
                for(int j=0; j<levelCols; j++)
                {
                    if(!bNoMore[i][j])
                    {
                        if(nTotal[i][j]>nNewFeaturesCell)
                        {
                            nToRetain[i][j] = nNewFeaturesCell;
                            bNoMore[i][j] = false;
                        }
                        else
                        {
                            nToRetain[i][j] = nTotal[i][j];
                            nToDistribute += nNewFeaturesCell-nTotal[i][j];
                            bNoMore[i][j] = true;
                            nNoMore++;
                        }
                    }
                }
            }
        }

        vector<KeyPoint> & keypoints = allKeypoints[level];
        keypoints.reserve(nDesiredFeatures*2);

        const int scaledPatchSize = PATCH_SIZE*mvScaleFactor[level];

        // Retain by score and transform coordinates
        for(int i=0; i<levelRows; i++)
        {
            for(int j=0; j<levelCols; j++)
            {
                vector<KeyPoint> &keysCell = cellKeyPoints[i][j];
                KeyPointsFilter::retainBest(keysCell,nToRetain[i][j]);
                if((int)keysCell.size()>nToRetain[i][j])
                    keysCell.resize(nToRetain[i][j]);


                for(size_t k=0, kend=keysCell.size(); k<kend; k++)
                {
                    keysCell[k].pt.x+=iniXCol[j];
                    keysCell[k].pt.y+=iniYRow[i];
                    keysCell[k].octave=level;
                    keysCell[k].size = scaledPatchSize;
                    keypoints.push_back(keysCell[k]);
                }
            }
        }

        if((int)keypoints.size()>nDesiredFeatures)
        {
            KeyPointsFilter::retainBest(keypoints,nDesiredFeatures);
            keypoints.resize(nDesiredFeatures);
        }
    }

    // and compute orientations
    for (int level = 0; level < nlevels; ++level)
        computeOrientation(mvImagePyramid[level], allKeypoints[level], umax);
}

static void computeDescriptors(const Mat& image, vector<KeyPoint>& keypoints, Mat& descriptors,
                               const vector<Point>& pattern)
{
    descriptors = Mat::zeros((int)keypoints.size(), 32, CV_8UC1);

    for (size_t i = 0; i < keypoints.size(); i++)
        computeOrbDescriptor(keypoints[i], image, &pattern[0], descriptors.ptr((int)i));
}

void ORBextractor::operator()( InputArray _image, InputArray _mask, vector<KeyPoint>& _keypoints,
                      OutputArray _descriptors)
{ 
    if(_image.empty())
        return;

    Mat image = _image.getMat();
    assert(image.type() == CV_8UC1 );

    // Pre-compute the scale pyramid
    ComputePyramid(image);

    vector < vector<KeyPoint> > allKeypoints;
    ComputeKeyPointsOctTree(allKeypoints);
    //ComputeKeyPointsOld(allKeypoints);

    Mat descriptors;

    int nkeypoints = 0;
    for (int level = 0; level < nlevels; ++level)
        nkeypoints += (int)allKeypoints[level].size();
    if( nkeypoints == 0 )
        _descriptors.release();
    else
    {
        _descriptors.create(nkeypoints, 32, CV_8U);
        descriptors = _descriptors.getMat();
    }

    _keypoints.clear();
    _keypoints.reserve(nkeypoints);

    int offset = 0;
    for (int level = 0; level < nlevels; ++level)
    {
        vector<KeyPoint>& keypoints = allKeypoints[level];
        int nkeypointsLevel = (int)keypoints.size();

        if(nkeypointsLevel==0)
            continue;

        // preprocess the resized image
        Mat workingMat = mvImagePyramid[level].clone();
        GaussianBlur(workingMat, workingMat, Size(7, 7), 2, 2, BORDER_REFLECT_101);

        // Compute the descriptors
        Mat desc = descriptors.rowRange(offset, offset + nkeypointsLevel);
        computeDescriptors(workingMat, keypoints, desc, pattern);

        offset += nkeypointsLevel;

        // Scale keypoint coordinates
        if (level != 0)
        {
            float scale = mvScaleFactor[level]; //getScale(level, firstLevel, scaleFactor);
            for (vector<KeyPoint>::iterator keypoint = keypoints.begin(),
                 keypointEnd = keypoints.end(); keypoint != keypointEnd; ++keypoint)
                keypoint->pt *= scale;
        }
        // And add the keypoints to the output
        _keypoints.insert(_keypoints.end(), keypoints.begin(), keypoints.end());
    }
}

void ORBextractor::ComputePyramid(cv::Mat image)
{
    for (int level = 0; level < nlevels; ++level)
    {
        float scale = mvInvScaleFactor[level];
        Size sz(cvRound((float)image.cols*scale), cvRound((float)image.rows*scale));
        Size wholeSize(sz.width + EDGE_THRESHOLD*2, sz.height + EDGE_THRESHOLD*2);
        Mat temp(wholeSize, image.type()), masktemp;
        mvImagePyramid[level] = temp(Rect(EDGE_THRESHOLD, EDGE_THRESHOLD, sz.width, sz.height));

        // Compute the resized image
        if( level != 0 )
        {
            resize(mvImagePyramid[level-1], mvImagePyramid[level], sz, 0, 0, INTER_LINEAR);

            copyMakeBorder(mvImagePyramid[level], temp, EDGE_THRESHOLD, EDGE_THRESHOLD, EDGE_THRESHOLD, EDGE_THRESHOLD,
                           BORDER_REFLECT_101+BORDER_ISOLATED);            
        }
        else
        {
            copyMakeBorder(image, temp, EDGE_THRESHOLD, EDGE_THRESHOLD, EDGE_THRESHOLD, EDGE_THRESHOLD,
                           BORDER_REFLECT_101);            
        }
    }

}

} //namespace ORB_SLAM
",16291,True,3270.544752332666,median
"= CAQH Connector Reference - Mule 4
:page-aliases: connectors::caqh/caqh-connector-reference.adoc

Support Category: https://www.mulesoft.com/legal/versioning-back-support-policy#anypoint-connectors[Select]

CAQH Connector v1.0

Release Notes: xref:release-notes::connector/caqh-connector-release-notes-mule-4.adoc[CAQH Connector Release Notes]


The main class of an extension, is the entry point from which configurations, connection providers, operations and sources are going to be declared.


== Configurations
---
[[config]]
=== Default Configuration


Default configuration


==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
|Name | String | The name for this configuration. Connectors reference the configuration with this name. | |x
| Connection a| <<config_connection, Connection>>
 | The connection types to provide to this configuration. | |x
| Address a| String |  |  |x
| Version a| String |  |  |
| Expiration Policy a| <<ExpirationPolicy>> |  Configures the minimum amount of time that a dynamic configuration instance can remain idle before the runtime considers it eligible for expiration. This does not mean that the platform expires the instance at the exact moment that it becomes eligible. The runtime purges the instances when it sees fit. |  |
|===

==== Connection Types
[[config_connection]]
===== Connection


This class (as its name implies) provides connection instances and the functionality to disconnect and validate those connections.  All connection related parameters (values required to create a connection) must be declared in the connection providers.  This particular example is a PoolingConnectionProvider which declares that connections resolved by this provider will be pooled and reused. There are other implementations like CachedConnectionProvider which lazily creates and caches connections or simply ConnectionProvider if you want a new connection each time something requires one.


====== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Username a| String |  |  |x
| Password a| String |  |  |x
| Use Persistent Connections a| Boolean |  If false, each connection will be closed after the first request is completed. |  true |
| Max Connections a| Number |  The maximum number of outbound connections that will be kept open at the same time. By default the number of connections is unlimited. |  -1 |
| Connection Idle Timeout a| Number |  The number of milliseconds that a connection can remain idle before it is closed. The value of this attribute is only used when persistent connections are enabled. |  60000 |
| Stream Response a| Boolean |  Whether or not received responses should be streamed, meaning processing will continue as soon as all headers are parsed and the body streamed as it arrives. When enabled, the response MUST be eventually read since depending on the configured buffer size it may not fit into memory and processing will stop until space is available. |  false |
| Response Buffer Size a| Number |  The space in bytes for the buffer where the HTTP response will be stored. |  -1 |
| Connection Timeout a| Number |  |  60000 |
| TLS Configuration a| <<Tls>> |  Protocol to use for communication. Valid values are HTTP and HTTPS. Default value is HTTP. When using HTTPS the HTTP communication is going to be secured using TLS / SSL. If HTTPS was configured as protocol then the user needs to configure at least the keystore in the tls:context child element of this listener-config. |  |
| Reconnection a| <<Reconnection>> |  When the application is deployed, a connectivity test is performed on all connectors. If set to true, deployment fails if the test doesn't pass after exhausting the associated reconnection strategy |  |
|===

== Supported Operations
* <<addToRosterRequestDa>>
* <<addToRosterRequestPv>>
* <<deleteFromProviewApi>>
* <<deleteFromProviewApiDa>>
* <<deleteFromRosterRequestDaByPutRequest>>
* <<deleteFromRosterRequestPv>>
* <<getProviderCredentials>>
* <<getProviderDocument>>
* <<getProviderStatusDa>>
* <<getProviderStatusProview>>
* <<getResultOfAddRequest>>
* <<getResultOfDeleteRequest>>
* <<getResultOfUpdateRequest>>
* <<updateToProviewApiDa>>
* <<updateToRosterRequestDaByPutRequest>>
* <<updateToRosterRequestPv>>
* <<updateToRosterRequestPvByPutRequest>>



== Operations

[[addToRosterRequestDa]]
=== Add Providers - DirectAssure
`<caqh:add-to-roster-request-da>`


A partner organization (PO) can add one or more providers to the roster by submitting a call to the API. For this there are different required and optional fields for the Quick Add verses the Initial Add. Returns the batch_id that is generated on successful addition of providers on the roster.


==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Add To DA Bodies a| Array of <<RequestToAddRosterPVDTO>> |  List of providers to be added to roster |  `#[payload]` |
| Streaming Strategy a| * <<repeatable-in-memory-stream>>
* <<repeatable-file-store-stream>>
* non-repeatable-stream |  Configure to use repeatable streams. |  |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Any
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:METHOD_NOT_ALLOWED
* CAQH:INTERNAL_SERVER_ERROR
* CAQH:NOT_ACCEPTABLE
* CAQH:REQUEST_TIMEOUT
* CAQH:GENERIC_EXCEPTION
* CAQH:BAD_GATEWAY
* CAQH:NOT_IMPLEMENTED
* CAQH:RETRY_EXHAUSTED
* CAQH:EMPTY_HEAD_COUNT
* CAQH:CONFLICT
* CAQH:SERVICE_UNAVAILABLE
* CAQH:DEAD_TOKEN
* CAQH:BAD_REQUEST
* CAQH:FORBIDDEN
* CAQH:UNAUTHORIZED
* CAQH:NOT_FOUND
* CAQH:CONNECTIVITY


[[addToRosterRequestPv]]
=== Add Providers - ProView
`<caqh:add-to-roster-request-pv>`


A PO can add one or more providers to the roster by submitting a call to the API. For this there are different required and optional fields for the Quick Add verses the Initial Add. This method returns the batch_id that is generated on successful addition of Providers on roster.


==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Add Request Bodies a| Array of <<RequestToAddRosterPVDTO>> |  List of providers to be added to Roster. |  `#[payload]` |
| Streaming Strategy a| * <<repeatable-in-memory-stream>>
* <<repeatable-file-store-stream>>
* non-repeatable-stream |  Configure to use repeatable streams. |  |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Any
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:METHOD_NOT_ALLOWED
* CAQH:INTERNAL_SERVER_ERROR
* CAQH:NOT_ACCEPTABLE
* CAQH:REQUEST_TIMEOUT
* CAQH:GENERIC_EXCEPTION
* CAQH:BAD_GATEWAY
* CAQH:NOT_IMPLEMENTED
* CAQH:RETRY_EXHAUSTED
* CAQH:EMPTY_HEAD_COUNT
* CAQH:CONFLICT
* CAQH:SERVICE_UNAVAILABLE
* CAQH:DEAD_TOKEN
* CAQH:BAD_REQUEST
* CAQH:FORBIDDEN
* CAQH:UNAUTHORIZED
* CAQH:NOT_FOUND
* CAQH:CONNECTIVITY


[[deleteFromProviewApi]]
=== Delete Providers - ProView (POST)
`<caqh:delete-from-proview-api>`


Method to delete one or more providers from the roster using POST. Returns the batch_id that is generated on successful deletion of Providers from roster.


==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Delete Proview Bodies a| Array of <<RequestToDeleteRosterDADTO>> |  List of providers to be deleted from Proview. |  `#[payload]` |
| Streaming Strategy a| * <<repeatable-in-memory-stream>>
* <<repeatable-file-store-stream>>
* non-repeatable-stream |  Configure to use repeatable streams. |  |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Any
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:RETRY_EXHAUSTED
* CAQH:CONNECTIVITY


[[deleteFromProviewApiDa]]
=== Delete Providers - DirectAssure (POST)
`<caqh:delete-from-proview-api-da>`


Method to delete one or more providers from the roster. Returns the batch_id that is generated on successful deletion of Providers from roster.


==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Delete DA By Post Bodies a| Array of <<RequestToDeleteRosterDADTO>> |  List of providers to be deleted from Proview. |  `#[payload]` |
| Streaming Strategy a| * <<repeatable-in-memory-stream>>
* <<repeatable-file-store-stream>>
* non-repeatable-stream |  Configure to use repeatable streams. |  |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Any
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:METHOD_NOT_ALLOWED
* CAQH:INTERNAL_SERVER_ERROR
* CAQH:NOT_ACCEPTABLE
* CAQH:REQUEST_TIMEOUT
* CAQH:GENERIC_EXCEPTION
* CAQH:BAD_GATEWAY
* CAQH:NOT_IMPLEMENTED
* CAQH:RETRY_EXHAUSTED
* CAQH:EMPTY_HEAD_COUNT
* CAQH:CONFLICT
* CAQH:SERVICE_UNAVAILABLE
* CAQH:DEAD_TOKEN
* CAQH:BAD_REQUEST
* CAQH:FORBIDDEN
* CAQH:UNAUTHORIZED
* CAQH:NOT_FOUND
* CAQH:CONNECTIVITY


[[deleteFromRosterRequestDaByPutRequest]]
=== Delete Providers - DirectAssure (PUT)
`<caqh:delete-from-roster-request-da-by-put-request>`


Method to delete one or more providers from the roster. Returns the batch_id that is generated on successful deletion of Providers from roster.


==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Delete DA By Put Bodies a| Array of <<RequestToDeleteRosterDADTO>> |  List of providers to be deleted from the roster |  `#[payload]` |
| Streaming Strategy a| * <<repeatable-in-memory-stream>>
* <<repeatable-file-store-stream>>
* non-repeatable-stream |  Configure to use repeatable streams. |  |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Any
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:METHOD_NOT_ALLOWED
* CAQH:INTERNAL_SERVER_ERROR
* CAQH:NOT_ACCEPTABLE
* CAQH:REQUEST_TIMEOUT
* CAQH:GENERIC_EXCEPTION
* CAQH:BAD_GATEWAY
* CAQH:NOT_IMPLEMENTED
* CAQH:RETRY_EXHAUSTED
* CAQH:EMPTY_HEAD_COUNT
* CAQH:CONFLICT
* CAQH:SERVICE_UNAVAILABLE
* CAQH:DEAD_TOKEN
* CAQH:BAD_REQUEST
* CAQH:FORBIDDEN
* CAQH:UNAUTHORIZED
* CAQH:NOT_FOUND
* CAQH:CONNECTIVITY


[[deleteFromRosterRequestPv]]
=== Delete Providers - ProView (PUT)
`<caqh:delete-from-roster-request-pv>`


Method to delete one or more providers from the roster using PUT. Returns the batch_id that is generated on successful deletion of Providers from roster.


==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Delete Request Bodies a| Array of <<RequestToDeleteRosterDADTO>> |  List of providers to be deleted from Roster. |  `#[payload]` |
| Streaming Strategy a| * <<repeatable-in-memory-stream>>
* <<repeatable-file-store-stream>>
* non-repeatable-stream |  Configure to use repeatable streams. |  |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Any
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:RETRY_EXHAUSTED
* CAQH:CONNECTIVITY


[[getProviderCredentials]]
=== Get Provider Credentials
`<caqh:get-provider-credentials>`

This method returns the xml response received by Credentialing API web service which is used by Participating Organizations to access real-time provider data from CAQH ProView. Before requesting the Credentialing API access, POs should have a business case and an existing application with which to consume and use the web service. The credentialing API is designed to accept one CAQH Provider ID at a time and disseminate information for that provider based on other parameters provided in the API call. The Credentialing API service will return provider data only if it satisfies all of the following criteria:

. Provider application status is Complete.
. Provider has Authorized the Participating Organization to see their information. participating organization roster status of the provider is active. Data will be filtered based on Delegated/Non-Delegated and Participating/Non-Participating relationships between the participating organization and the requested provider.

==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Caqh Provider Id a| String |  CAQH assigned provider Identifier. |  |x
| Organization Id a| String |  Participating Organization Identifier. |  |x
| Attestation Date a| String |  Date on which provider was last first attested.Required (Only within the past 3 years). |  |x
| Credential Section a| String |  (Optional) If not specified, the service will return all sections. |  |
| Streaming Strategy a| * <<repeatable-in-memory-stream>>
* <<repeatable-file-store-stream>>
* non-repeatable-stream |  Configure to use repeatable streams. |  |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Any
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:METHOD_NOT_ALLOWED
* CAQH:INTERNAL_SERVER_ERROR
* CAQH:NOT_ACCEPTABLE
* CAQH:REQUEST_TIMEOUT
* CAQH:GENERIC_EXCEPTION
* CAQH:BAD_GATEWAY
* CAQH:NOT_IMPLEMENTED
* CAQH:RETRY_EXHAUSTED
* CAQH:EMPTY_HEAD_COUNT
* CAQH:CONFLICT
* CAQH:SERVICE_UNAVAILABLE
* CAQH:DEAD_TOKEN
* CAQH:BAD_REQUEST
* CAQH:FORBIDDEN
* CAQH:UNAUTHORIZED
* CAQH:NOT_FOUND
* CAQH:CONNECTIVITY


[[getProviderDocument]]
=== Get Provider Documents
`<caqh:get-provider-document>`

This method returns the PDF document in response to request that allows a participating organization to retrieve a provider's supporting document The supporting documents will be returned only if the following are true:

. The requesting user's associated PO ID matches with the incoming PO ID, or if the incoming is the child of the user's associated PO ID.
. The provider is on the participating organization's roster.
. The provider has given authorization to the participating organization.
. The provider's CAQH ProView data profile is in a complete status, e.g. Initial Profile Complete or Re-attestation. If these criteria are not satisfied then the supporting document for that CAQH Provider ID is not be returned and the appropriate response code is be supplied.

==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Caqh Provider_id a| String |  CAQH assigned provider Identifier. |  |x
| Organization_id a| String |  Participating Organization Identifier. |  |x
| Doc_ Type a| String |  Single Supporting Document Type. |  |x
| Output Mime Type a| String |  The mime type of the payload that this operation outputs. |  |
| Output Encoding a| String |  The encoding of the payload that this operation outputs. |  |
| Streaming Strategy a| * <<repeatable-in-memory-stream>>
* <<repeatable-file-store-stream>>
* non-repeatable-stream |  Configure to use repeatable streams. |  |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Binary
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:METHOD_NOT_ALLOWED
* CAQH:INTERNAL_SERVER_ERROR
* CAQH:NOT_ACCEPTABLE
* CAQH:REQUEST_TIMEOUT
* CAQH:GENERIC_EXCEPTION
* CAQH:BAD_GATEWAY
* CAQH:NOT_IMPLEMENTED
* CAQH:RETRY_EXHAUSTED
* CAQH:EMPTY_HEAD_COUNT
* CAQH:CONFLICT
* CAQH:SERVICE_UNAVAILABLE
* CAQH:DEAD_TOKEN
* CAQH:BAD_REQUEST
* CAQH:FORBIDDEN
* CAQH:UNAUTHORIZED
* CAQH:NOT_FOUND
* CAQH:CONNECTIVITY


[[getProviderStatusDa]]
=== Get Provider Status - DirectAssure
`<caqh:get-provider-status-da>`


The DirectAssure Status Check API web service can be used by Participating Organizations to view the status of providers in CAQH ProView. Before requesting DirectAssure Status Check API access, partner organizations should have a business case and an existing application with which to consume and use the web service. The DirectAssure Status Check API accepts one provider at a time.


==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Organization_ Id a| String |  Participating organization identifier |  |x
| Caqh_ Provider_ Id a| String |  CAQH assigned provider identifier |  |x
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |<<GetProviderStatusDTO>>
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:METHOD_NOT_ALLOWED
* CAQH:INTERNAL_SERVER_ERROR
* CAQH:NOT_ACCEPTABLE
* CAQH:REQUEST_TIMEOUT
* CAQH:GENERIC_EXCEPTION
* CAQH:BAD_GATEWAY
* CAQH:NOT_IMPLEMENTED
* CAQH:RETRY_EXHAUSTED
* CAQH:EMPTY_HEAD_COUNT
* CAQH:CONFLICT
* CAQH:SERVICE_UNAVAILABLE
* CAQH:DEAD_TOKEN
* CAQH:BAD_REQUEST
* CAQH:FORBIDDEN
* CAQH:UNAUTHORIZED
* CAQH:NOT_FOUND
* CAQH:CONNECTIVITY


[[getProviderStatusProview]]
=== Get Provider Status - ProView
`<caqh:get-provider-status-proview>`


The ProView Status Check API web service can be used by Participating Organizations to view the status of providers in CAQH ProView. Before requesting ProView Status Check API access, POs should have a business case and an existing application with which to consume and use the web service. The ProView Status Check API accepts one provider at a time. This method returns a JSON response with the status of provider or indicate that a provider could not be found with Provider_Found_Flag equal to N.


==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Organization_ Id a| String |  Participating Organization Identifier. |  |x
| Caqh_ Provider_ Id a| String |  CAQH assigned provider Identifier. |  |x
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |<<GetProviderStatusDTO>>
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:METHOD_NOT_ALLOWED
* CAQH:INTERNAL_SERVER_ERROR
* CAQH:NOT_ACCEPTABLE
* CAQH:REQUEST_TIMEOUT
* CAQH:GENERIC_EXCEPTION
* CAQH:BAD_GATEWAY
* CAQH:NOT_IMPLEMENTED
* CAQH:RETRY_EXHAUSTED
* CAQH:EMPTY_HEAD_COUNT
* CAQH:CONFLICT
* CAQH:SERVICE_UNAVAILABLE
* CAQH:DEAD_TOKEN
* CAQH:BAD_REQUEST
* CAQH:FORBIDDEN
* CAQH:UNAUTHORIZED
* CAQH:NOT_FOUND
* CAQH:CONNECTIVITY


[[getResultOfAddRequest]]
=== Get Status - Add to Roster
`<caqh:get-result-of-add-request>`


Method to get the status of a previous Add to Roster request, and the results if the request is complete. If a provider is unable to be added to the roster due to an Exception, then the Exception_Description field contains a value and the identifying fields submitted in the Add to Roster Web Service is returned instead of the values from the system.


==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Batch_id a| String |  System-generated unique Batch ID from ADD request. |  |x
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |<<GetAddStatusDTO>>
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:METHOD_NOT_ALLOWED
* CAQH:INTERNAL_SERVER_ERROR
* CAQH:NOT_ACCEPTABLE
* CAQH:REQUEST_TIMEOUT
* CAQH:GENERIC_EXCEPTION
* CAQH:BAD_GATEWAY
* CAQH:NOT_IMPLEMENTED
* CAQH:RETRY_EXHAUSTED
* CAQH:EMPTY_HEAD_COUNT
* CAQH:CONFLICT
* CAQH:SERVICE_UNAVAILABLE
* CAQH:DEAD_TOKEN
* CAQH:BAD_REQUEST
* CAQH:FORBIDDEN
* CAQH:UNAUTHORIZED
* CAQH:NOT_FOUND
* CAQH:CONNECTIVITY


[[getResultOfDeleteRequest]]
=== Get Status - Delete from Roster
`<caqh:get-result-of-delete-request>`


GET request to receive the status of a previous Delete from Roster request, and the results if the request is complete. If a provider is unable to be deleted from the roster due to an exception, then the Delete_Description field contains the exception.


==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Batch_id a| String |  System-generated unique Batch ID from UPDATE request. |  |x
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |<<GetDeleteResultDTO>>
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:METHOD_NOT_ALLOWED
* CAQH:INTERNAL_SERVER_ERROR
* CAQH:NOT_ACCEPTABLE
* CAQH:REQUEST_TIMEOUT
* CAQH:GENERIC_EXCEPTION
* CAQH:BAD_GATEWAY
* CAQH:NOT_IMPLEMENTED
* CAQH:RETRY_EXHAUSTED
* CAQH:EMPTY_HEAD_COUNT
* CAQH:CONFLICT
* CAQH:SERVICE_UNAVAILABLE
* CAQH:DEAD_TOKEN
* CAQH:BAD_REQUEST
* CAQH:FORBIDDEN
* CAQH:UNAUTHORIZED
* CAQH:NOT_FOUND
* CAQH:CONNECTIVITY


[[getResultOfUpdateRequest]]
=== Get Status - Update to Roster
`<caqh:get-result-of-update-request>`


GET request to receive the status of a previous Update on Roster request, and the results if the request is complete. If a provider is unable to be updated on the roster due to an exception, then the Update_Description field contains the exception.


==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Batch_id a| String |  System-generated unique Batch ID from UPDATE request. |  |x
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |<<GetUpdateResultDTO>>
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:METHOD_NOT_ALLOWED
* CAQH:INTERNAL_SERVER_ERROR
* CAQH:NOT_ACCEPTABLE
* CAQH:REQUEST_TIMEOUT
* CAQH:GENERIC_EXCEPTION
* CAQH:BAD_GATEWAY
* CAQH:NOT_IMPLEMENTED
* CAQH:RETRY_EXHAUSTED
* CAQH:EMPTY_HEAD_COUNT
* CAQH:CONFLICT
* CAQH:SERVICE_UNAVAILABLE
* CAQH:DEAD_TOKEN
* CAQH:BAD_REQUEST
* CAQH:FORBIDDEN
* CAQH:UNAUTHORIZED
* CAQH:NOT_FOUND
* CAQH:CONNECTIVITY


[[updateToProviewApiDa]]
=== Update Providers - DirectAssure (POST)
`<caqh:update-to-proview-api-da>`


Method to update one or more providers existing on roster. Returns the batch_id that is generated on successful update of providers on the roster.


==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Update DA By Post Requests a| Array of <<RequestToUpdateDADTO>> |  List of providers to be updated in ProView |  `#[payload]` |
| Streaming Strategy a| * <<repeatable-in-memory-stream>>
* <<repeatable-file-store-stream>>
* non-repeatable-stream |  Configure to use repeatable streams. |  |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Any
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:METHOD_NOT_ALLOWED
* CAQH:INTERNAL_SERVER_ERROR
* CAQH:NOT_ACCEPTABLE
* CAQH:REQUEST_TIMEOUT
* CAQH:GENERIC_EXCEPTION
* CAQH:BAD_GATEWAY
* CAQH:NOT_IMPLEMENTED
* CAQH:RETRY_EXHAUSTED
* CAQH:EMPTY_HEAD_COUNT
* CAQH:CONFLICT
* CAQH:SERVICE_UNAVAILABLE
* CAQH:DEAD_TOKEN
* CAQH:BAD_REQUEST
* CAQH:FORBIDDEN
* CAQH:UNAUTHORIZED
* CAQH:NOT_FOUND
* CAQH:CONNECTIVITY


[[updateToRosterRequestDaByPutRequest]]
=== Update Providers - DirectAssure (PUT)
`<caqh:update-to-roster-request-da-by-put-request>`


Method to update one or more providers existing on roster. Returns the batch_id that is generated on successful update of providers on the roster.


==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Update DA By Put Requests a| Array of <<RequestToUpdateDADTO>> |  List of providers to be updated in roster |  `#[payload]` |
| Streaming Strategy a| * <<repeatable-in-memory-stream>>
* <<repeatable-file-store-stream>>
* non-repeatable-stream |  Configure to use repeatable streams. |  |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Any
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:METHOD_NOT_ALLOWED
* CAQH:INTERNAL_SERVER_ERROR
* CAQH:NOT_ACCEPTABLE
* CAQH:REQUEST_TIMEOUT
* CAQH:GENERIC_EXCEPTION
* CAQH:BAD_GATEWAY
* CAQH:NOT_IMPLEMENTED
* CAQH:RETRY_EXHAUSTED
* CAQH:EMPTY_HEAD_COUNT
* CAQH:CONFLICT
* CAQH:SERVICE_UNAVAILABLE
* CAQH:DEAD_TOKEN
* CAQH:BAD_REQUEST
* CAQH:FORBIDDEN
* CAQH:UNAUTHORIZED
* CAQH:NOT_FOUND
* CAQH:CONNECTIVITY


[[updateToRosterRequestPv]]
=== Update Providers - ProView (POST)
`<caqh:update-to-roster-request-pv>`


Method to update one or more providers existing on roster using POST. Returns the batch_id that is generated on successful update of Providers on roster.


==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Update Proview Details a| Array of <<RequestToUpdatePVDTO>> |  List of providers to be updated in Proview. |  `#[payload]` |
| Streaming Strategy a| * <<repeatable-in-memory-stream>>
* <<repeatable-file-store-stream>>
* non-repeatable-stream |  Configure to use repeatable streams. |  |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Any
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:METHOD_NOT_ALLOWED
* CAQH:INTERNAL_SERVER_ERROR
* CAQH:NOT_ACCEPTABLE
* CAQH:REQUEST_TIMEOUT
* CAQH:GENERIC_EXCEPTION
* CAQH:BAD_GATEWAY
* CAQH:NOT_IMPLEMENTED
* CAQH:RETRY_EXHAUSTED
* CAQH:EMPTY_HEAD_COUNT
* CAQH:CONFLICT
* CAQH:SERVICE_UNAVAILABLE
* CAQH:DEAD_TOKEN
* CAQH:BAD_REQUEST
* CAQH:FORBIDDEN
* CAQH:UNAUTHORIZED
* CAQH:NOT_FOUND
* CAQH:CONNECTIVITY


[[updateToRosterRequestPvByPutRequest]]
=== Update Providers - ProView (PUT)
`<caqh:update-to-roster-request-pv-by-put-request>`


Method to update one or more providers existing on roster using PUT. Returns the batch_id that is generated on successful update of Providers on roster.


==== Parameters
[%header%autowidth.spread]
|===
| Name | Type | Description | Default Value | Required
| Configuration | String | The name of the configuration to use. | |x
| Details a| Array of <<RequestToUpdatePVDTO>> |  List of providers to be updated in Roster. |  `#[payload]` |
| Streaming Strategy a| * <<repeatable-in-memory-stream>>
* <<repeatable-file-store-stream>>
* non-repeatable-stream |  Configure to use repeatable streams. |  |
| Target Variable a| String |  The name of a variable to store the operation's output. |  |
| Target Value a| String |  An expression to evaluate against the operation's output and store the expression outcome in the target variable |  `#[payload]` |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> |  A retry strategy in case of connectivity errors. |  |
|===

==== Output
[%autowidth.spread]
|===
|Type |Any
| Attributes Type a| <<ResponseStatus>>
|===

==== For Configurations
* <<config>>

==== Throws
* CAQH:METHOD_NOT_ALLOWED
* CAQH:INTERNAL_SERVER_ERROR
* CAQH:NOT_ACCEPTABLE
* CAQH:REQUEST_TIMEOUT
* CAQH:GENERIC_EXCEPTION
* CAQH:BAD_GATEWAY
* CAQH:NOT_IMPLEMENTED
* CAQH:RETRY_EXHAUSTED
* CAQH:EMPTY_HEAD_COUNT
* CAQH:CONFLICT
* CAQH:SERVICE_UNAVAILABLE
* CAQH:DEAD_TOKEN
* CAQH:BAD_REQUEST
* CAQH:FORBIDDEN
* CAQH:UNAUTHORIZED
* CAQH:NOT_FOUND
* CAQH:CONNECTIVITY



== Types
[[Tls]]
=== TLS

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Enabled Protocols a| String | A comma-separated list of protocols enabled for this context. |  |
| Enabled Cipher Suites a| String | A comma-separated list of cipher suites enabled for this context. |  |
| Trust Store a| <<TrustStore>> |  |  |
| Key Store a| <<KeyStore>> |  |  |
| Revocation Check a| * <<standard-revocation-check>>
* <<custom-ocsp-responder>>
* <<crl-file>> |  |  |
|===

[[TrustStore]]
=== Trust Store

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Path a| String | The location (which will be resolved relative to the current classpath and file system, if possible) of the trust store. |  |
| Password a| String | The password used to protect the trust store. |  |
| Type a| String | The type of store used. |  |
| Algorithm a| String | The algorithm used by the trust store. |  |
| Insecure a| Boolean | If true, no certificate validations will be performed, rendering connections vulnerable to attacks. Use at your own risk. |  |
|===

[[KeyStore]]
=== Key Store

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Path a| String | The location (which will be resolved relative to the current classpath and file system, if possible) of the key store. |  |
| Type a| String | The type of store used. |  |
| Alias a| String | When the key store contains many private keys, this attribute indicates the alias of the key that should be used. If not defined, the first key in the file will be used by default. |  |
| Key Password a| String | The password used to protect the private key. |  |
| Password a| String | The password used to protect the key store. |  |
| Algorithm a| String | The algorithm used by the key store. |  |
|===

[[standard-revocation-check]]
=== Standard Revocation Check

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Only End Entities a| Boolean | Only verify the last element of the certificate chain. |  |
| Prefer CRLs a| Boolean | Try CRL instead of OCSP first. |  |
| No Fallback a| Boolean | Do not use the secondary checking method (the one not selected before). |  |
| Soft Fail a| Boolean | Avoid verification failure when the revocation server can not be reached or is busy. |  |
|===

[[custom-ocsp-responder]]
=== Custom OCSP Responder

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Url a| String | The URL of the OCSP responder. |  |
| Cert Alias a| String | Alias of the signing certificate for the OCSP response (must be in the trust store), if present. |  |
|===

[[crl-file]]
=== CRL File

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Path a| String | The path to the CRL file. |  |
|===

[[Reconnection]]
=== Reconnection

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Fails Deployment a| Boolean | When the application is deployed, a connectivity test is performed on all connectors. If set to true, deployment fails if the test doesn't pass after exhausting the associated reconnection strategy. |  |
| Reconnection Strategy a| * <<reconnect>>
* <<reconnect-forever>> | The reconnection strategy to use. |  |
|===

[[reconnect]]
=== Reconnect

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Frequency a| Number | How often in milliseconds to reconnect. | |
| Count a| Number | How many reconnection attempts to make.. | |
| blocking |Boolean |If false, the reconnection strategy runs in a separate, non-blocking thread. |true |
|===

[[reconnect-forever]]
=== Reconnect Forever

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Frequency a| Number | How often in milliseconds to reconnect. | |
| blocking |Boolean |If false, the reconnection strategy runs in a separate, non-blocking thread. |true |
|===

[[ExpirationPolicy]]
=== Expiration Policy

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Max Idle Time a| Number | A scalar time value for the maximum amount of time a dynamic configuration instance should be allowed to be idle before it's considered eligible for expiration |  |
| Time Unit a| Enumeration, one of:

** NANOSECONDS
** MICROSECONDS
** MILLISECONDS
** SECONDS
** MINUTES
** HOURS
** DAYS | A time unit that qualifies the maxIdleTime attribute |  |
|===

[[ResponseStatus]]
=== Response Status

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Headers a| Object |  |  |
| Status Code a| Number |  |  |
|===

[[RequestToAddRosterPVDTO]]
=== Request To Add Roster PVDTO

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Affiliation Flag a| String |  |  |
| Application Type a| String |  |  |
| Caqh Provider Id a| String |  |  |
| Delegation Flag a| String |  |  |
| Last Recredential Date a| String |  |  |
| Next Recredential Date a| String |  |  |
| Organization Id a| String |  |  |
| Po Provider Id a| String |  |  |
| Provider a| <<ProviderDTO>> |  |  |
| Region Id a| String |  |  |
|===

[[ProviderDTO]]
=== Provider DTO

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Address1 a| String |  |  |
| Address2 a| String |  |  |
| Birthdate a| String |  |  |
| City a| String |  |  |
| Dea a| String |  |  |
| Email a| String |  |  |
| Fax a| String |  |  |
| First Name a| String |  |  |
| Gender a| String |  |  |
| Last Name a| String |  |  |
| License Number a| String |  |  |
| License State a| String |  |  |
| Middle Name a| String |  |  |
| Name Suffix a| String |  |  |
| Npi a| String |  |  |
| Phone a| String |  |  |
| Practice State a| String |  |  |
| Short Ssn a| String |  |  |
| Ssn a| String |  |  |
| State a| String |  |  |
| Tax Id a| String |  |  |
| Type a| String |  |  |
| Upin a| String |  |  |
| Zip a| String |  |  |
| Zip Extn a| String |  |  |
|===

[[repeatable-in-memory-stream]]
=== Repeatable In Memory Stream

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Initial Buffer Size a| Number | The amount of memory to allocate to consume the stream and provide random access to it. If the stream contains more data than can fit into this buffer, then the buffer expands according to the bufferSizeIncrement attribute, with an upper limit of maxInMemorySize. |  |
| Buffer Size Increment a| Number | This is by how much the buffer size expands if it exceeds its initial size. Setting a value of zero or lower means that the buffer should not expand, meaning that a STREAM_MAXIMUM_SIZE_EXCEEDED error is raised when the buffer gets full. |  |
| Max Buffer Size a| Number | The maximum amount of memory to use. If more than that is used then a STREAM_MAXIMUM_SIZE_EXCEEDED error is raised. A value lower than or equal to zero means no limit. |  |
| Buffer Unit a| Enumeration, one of:

** BYTE
** KB
** MB
** GB | The unit in which all these attributes are expressed |  |
|===

[[repeatable-file-store-stream]]
=== Repeatable File Store Stream

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Max In Memory Size a| Number | Defines the maximum memory that the stream should use to keep data in memory. If more than that is consumed then it will start to buffer the content on disk. |  |
| Buffer Unit a| Enumeration, one of:

** BYTE
** KB
** MB
** GB | The unit in which maxInMemorySize is expressed |  |
|===

[[RequestToDeleteRosterDADTO]]
=== Request To Delete Roster DADTO

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Caqh Provider Id a| String |  |  |
| Organization Id a| String |  |  |
|===

[[GetProviderStatusDTO]]
=== Get Provider Status DTO

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Authorization Flag a| String |  |  |
| Caqh Provider Id a| String |  |  |
| Organization Id a| String |  |  |
| Po Provider Id a| String |  |  |
| Provider Found Flag a| String |  |  |
| Provider Practice State a| String |  |  |
| Provider Status a| String |  |  |
| Provider Status Date a| String |  |  |
| Roster Status a| String |  |  |
|===

[[GetAddStatusDTO]]
=== Get Add Status DTO

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Batch Status a| String |  |  |
| Batch Time a| String |  |  |
| Roster Result a| Array of <<RosterResponse>> |  |  |
|===

[[RosterResponse]]
=== Roster Response

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Affiliation Flag a| String |  |  |
| Anniversary Date a| String |  |  |
| Authorization Flag a| String |  |  |
| Caqh Provider Id a| String |  |  |
| Delegation Flag a| String |  |  |
| Exception Description a| String |  |  |
| Non Responder Flag a| String |  |  |
| Organization Id a| String |  |  |
| Po Provider Id a| String |  |  |
| Provider a| <<Provider>> |  |  |
| Roster Status a| String |  |  |
|===

[[Provider]]
=== Provider

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Address1 a| String |  |  |
| Address2 a| String |  |  |
| Address City a| String |  |  |
| Address State a| String |  |  |
| Address Zip a| String |  |  |
| Birthdate a| String |  |  |
| Dea a| String |  |  |
| First Name a| String |  |  |
| Last Name a| String |  |  |
| License Number a| String |  |  |
| License State a| String |  |  |
| Middle Name a| String |  |  |
| Npi a| String |  |  |
| Practice State a| String |  |  |
| Status a| String |  |  |
| Status Date a| String |  |  |
| Type a| String |  |  |
| Upin a| String |  |  |
|===

[[GetDeleteResultDTO]]
=== Get Delete Result DTO

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Batch Status a| String |  |  |
| Batch Time a| String |  |  |
| Deroster Result a| Array of <<DerosterResult>> |  |  |
|===

[[DerosterResult]]
=== Deroster Result

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Caqh Provider Id a| String |  |  |
| Delete Description a| String |  |  |
| Organization Id a| String |  |  |
|===

[[GetUpdateResultDTO]]
=== Get Update Result DTO

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Batch Status a| String |  |  |
| Batch Time a| String |  |  |
| Roster Result a| Array of <<RosterResult>> |  |  |
|===

[[RosterResult]]
=== Roster Result

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Caqh Provider Id a| String |  |  |
| Organization Id a| String |  |  |
| Update Description a| String |  |  |
|===

[[RequestToUpdateDADTO]]
=== Request To Update DADTO

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Caqh Provider Id a| String |  |  |
| Organization Id a| String |  |  |
| Po Provider Id a| String |  |  |
|===

[[RequestToUpdatePVDTO]]
=== Request To Update PVDTO

[%header%autowidth.spread]
|===
| Field | Type | Description | Default Value | Required
| Affiliation Flag a| String |  |  |
| Application Type a| String |  |  |
| Caqh Provider Id a| String |  |  |
| Delegation Flag a| String |  |  |
| Last Recredential Date a| String |  |  |
| Next Recredential Date a| String |  |  |
| Organization Id a| String |  |  |
| Po Provider Id a| String |  |  |
|===

== See Also

https://help.mulesoft.com[MuleSoft Help Center]
",12190,True,3192.3152302921258,median
"//////////////////////////////////////////

  Licensed to the Apache Software Foundation (ASF) under one
  or more contributor license agreements.  See the NOTICE file
  distributed with this work for additional information
  regarding copyright ownership.  The ASF licenses this file
  to you under the Apache License, Version 2.0 (the
  ""License""); you may not use this file except in compliance
  with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an
  ""AS IS"" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, either express or implied.  See the License for the
  specific language governing permissions and limitations
  under the License.

//////////////////////////////////////////

= Object orientation
:jls: https://docs.oracle.com/javase/specs/jls/se14/html/
:javabeans: https://download.oracle.com/otndocs/jcp/7224-javabeans-1.01-fr-spec-oth-JSpec/

This chapter covers the object orientation of the Groovy programming language.

== Types

=== Primitive types

Groovy supports the same primitive types as those defined by the {jls}[Java Language Specification]:

* integral types: `byte` (8 bit), `short` (16 bit), `int` (32 bit) and `long` (64 bit)
* floating-point types: `float` (32 bit) and `double` (64 bit)
* `boolean` type (exactly `true` or `false`)
* `char` type (16 bit, usable as a numeric type, representing an UTF-16 code)

While Groovy declares and stores primitive fields and variables as primitives, because it uses Objects for
everything, it autowraps references to primitives. Just like Java, the wrappers it uses are

[cols=""1,1"" options=""header""]
.primitive wrappers
|====
| Primitive type
| Wrapper class

| boolean
| Boolean

| char
| Character

| short
| Short

| int
| Integer

| long
| Long

| float
| Float

| double
| Double
|====

Here's an example using `int`

[source,groovy]
----
include::../test/PrimitiveTest.groovy[tags=primitive_references,indent=0]
----

Now you may be concerned that this means every time you use a mathematical operator on a reference to a primitive
that you'll incur the cost of unboxing and reboxing the primitive. But this is not the case, as Groovy will compile
your operators into their link:core-operators.html#_operator-overloading[method equivalents] and uses those instead.
Additionally, Groovy will automatically unbox to a primitive when calling a Java method that takes a primitive
parameter and automatically box primitive method return values from Java. However, be aware there are some
link:core-differences-java.html#_primitives_and_wrappers[differences] from Java's method resolution.

=== Class

Groovy classes are very similar to Java classes, and are compatible with Java ones at JVM level.
They may have methods, fields and properties (think JavaBeans properties but with less boilerplate).
Classes and class members can have the same modifiers (public, protected, private, static, etc) as in Java
with some minor differences at the source level which are explained shortly.

The key differences between Groovy classes and their Java counterparts are:

* Classes or methods with no visibility modifier are automatically public (a special annotation can be used to achieve package private visibility).
* Fields with no visibility modifier are turned into properties automatically, which results in less verbose code,
since explicit getter and setter methods aren't needed. More on this aspect will be covered in the <<fields,fields and properties section>>.
* Classes do not need to have the same base name as their source file definitions but it is highly recommended in most scenarios (see also the next point about scripts).
* One source file may contain one or more classes (but if a file contains any code not in a class, it is considered a script). Scripts are just classes with some
special conventions and will have the same name as their source file (so don't include a class definition within a script having the same name as the script source file).

The following code presents an example class.

[source,groovy]
----
include::../test/ClassTest.groovy[tags=class_definition,indent=0]
----
<1> class beginning, with the name `Person`
<2> string field and property named `name`
<3> method definition


==== Normal class

Normal classes refer to classes which are top level and concrete. This means they can be instantiated without restrictions from any other classes or scripts. This way, they can only be public (even though the `public` keyword may be suppressed). Classes are instantiated by calling their constructors, using the `new` keyword, as in the following snippet.

[source,groovy]
----
include::../test/ClassTest.groovy[tags=class_instantiation,indent=0]
----


==== Inner class

Inner classes are defined within another classes. The enclosing class can use the inner class as usual. On the other side, a inner class can access members of its enclosing class, even if they are private. Classes other than the enclosing class are not allowed to access inner classes. Here is an example:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=inner_class,indent=0]
----
<1> the inner class is instantiated and its method gets called
<2> inner class definition, inside its enclosing class
<3> even being private, a field of the enclosing class is accessed by the inner class

There are some reasons for using inner classes:

 * They increase encapsulation by hiding the inner class from other classes, which do not need to know about it. This also leads to cleaner packages and workspaces.
 * They provide a good organization, by grouping classes that are used by only one class.
 * They lead to more maintainable codes, since inner classes are near the classes that use them.

It is common for an inner class to be an implementation of some interface whose method(s) are needed by the outer class.
The code below illustrates this typical usage pattern, here being used with threads.

[source,groovy]
----
include::../test/ClassTest.groovy[tags=inner_class2,indent=0]
----

Note that the class `Inner2` is defined only to provide an implementation of the method `run` to class `Outer2`.
Anonymous inner classes help to eliminate verbosity in this case.
That topic is covered shortly.

Groovy 3+ also supports Java syntax for non-static inner class instantiation, for example:

[source,groovy]
--------------------------------------
include::../test/ClassTest.groovy[tags=inner_instantiation,indent=0]
--------------------------------------

===== Anonymous inner class

The earlier example of an inner class (`Inner2`) can be simplified with an anonymous inner class.
The same functionality can be achieved with the following code:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=anonymous_inner_class,indent=0]
----
<1> comparing with the last example of previous section, the `new Inner2()` was replaced by `new Runnable()` along with all its implementation
<2> the method `start` is invoked normally

Thus, there was no need to define a new class to be used just once.

==== Abstract class

Abstract classes represent generic concepts, thus, they cannot be instantiated, being created to be subclassed.
Their members include fields/properties and abstract or concrete methods.
Abstract methods do not have implementation, and must be implemented by concrete subclasses.

[source,groovy]
----
include::../test/ClassTest.groovy[tags=abstract_class,indent=0]
----
<1> abstract classes must be declared with `abstract` keyword
<2> abstract methods must also be declared with `abstract` keyword

Abstract classes are commonly compared to interfaces.
There are at least two important differences of choosing one or another.
First, while abstract classes may contain fields/properties and concrete methods, interfaces may contain only abstract methods (method signatures).
Moreover, one class can implement several interfaces, whereas it can extend just one class, abstract or not.

=== Inheritance

Inheritance in Groovy resembles inheritance in Java.
It provides a mechanism for a child class (or subclass) to reuse
code or properties from a parent (or super class).
Classes related through inheritance form an inheritance hierarchy.
Common behavior and members are pushed up the hierarchy to reduce duplication.
Specializations occur in child classes.

Different forms of inheritance are supported:

* _implementation_ inheritance where code (methods, fields or properties) from a <<superclass,superclass>> or from
one or more <<_traits,traits>> is reused by a child class
* _contract_ inheritance where a class promises to provide particular abstract methods defined in a <<superclass,superclass>>,
or defined in one or more <<_traits,traits>> or <<_interface,interfaces>>.

=== Interface

An interface defines a contract that a class needs to conform to.
An interface only defines a list of methods that need
to be implemented, but does not define the method's implementation.

[source,groovy]
----
include::../test/ClassTest.groovy[tags=interface_def_1,indent=0]
----
<1> an interface needs to be declared using the `interface` keyword
<2> an interface only defines method signatures

Methods of an interface are always *public*. It is an error to use `protected` or `private` methods in interfaces:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=protected_forbidden,indent=0]
----
<1> Using `protected` is a compile-time error

A class _implements_ an interface if it defines the interface in its `implements` list or if any of its superclasses
does:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=class_implements,indent=0]
----
<1> The `SystemGreeter` declares the `Greeter` interface using the `implements` keyword
<2> Then implements the required `greet` method
<3> Any instance of `SystemGreeter` is also an instance of the `Greeter` interface

An interface can extend another interface:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=extended_interface,indent=0]
----
<1> the `ExtendedGreeter` interface extends the `Greeter` interface using the `extends` keyword

It is worth noting that for a class to be an instance of an interface, it has to be explicit. For example, the following
class defines the `greet` method as it is declared in the `Greeter` interface, but does not declare `Greeter` in its
interfaces:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=no_structural_interface,indent=0]
----

In other words, Groovy does not define structural typing. It is however possible to make an instance of an object
implement an interface at runtime, using the `as` coercion operator:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=interface_coercion,indent=0]
----
<1> create an instance of `DefaultGreeter` that does not implement the interface
<2> coerce the instance into a `Greeter` at runtime
<3> the coerced instance implements the `Greeter` interface

You can see that there are two distinct objects: one is the source object, a `DefaultGreeter` instance, which does not
implement the interface. The other is an instance of `Greeter` that delegates to the coerced object.

TIP: Groovy interfaces do not support default implementation like Java 8 interfaces. If you are looking for something
similar (but not equal), <<_traits,traits>> are close to interfaces, but allow default implementation as well as other
important features described in this manual.

[[superclass]]
=== Superclass

Parent classes share visible fields, properties or methods with child classes.
A child class may have at most one parent class.
The `extends` keyword is used immediately prior to giving the superclass type.

=== Constructors

Constructors are special methods used to initialize an object with a specific state. As with normal methods,
it is possible for a class to declare more than one constructor, so long as each constructor has a unique
type signature. If an object doesn't require any parameters during construction, it may use a _no-arg_ constructor.
If no constructors are supplied, an empty no-arg constructor will be provided by the Groovy compiler.

Groovy supports two invocation styles:

* _positional parameters_ are used in a similar to how you would use Java constructors
* _named parameters_ allow you to specify parameter names when invoking the constructor.

==== Positional parameters

To create an object by using positional parameters, the respective class needs to declare one or more
constructors. In the case of multiple constructors, each must have a unique type signature. The constructors can also
added to the class using the gapi:groovy.transform.TupleConstructor[] annotation.

Typically, once at least one constructor is declared, the class can only be instantiated by having one of its
constructors called. It is worth noting that, in this case, you can't normally create the class with named parameters.
Groovy does support named parameters so long as the class contains a no-arg constructor or provides a constructor which
takes a `Map` argument as the first (and potentially only) argument - see the next section for details.

There are three forms of using a declared constructor. The first one is the normal Java way, with the `new` keyword.
The others rely on coercion of lists into the desired types. In this case, it is possible to coerce with the `as`
keyword and by statically typing the variable.

[source,groovy]
----
include::../test/ClassTest.groovy[tags=constructor_positional_parameters,indent=0]
----
<1> Constructor declaration
<2> Constructor invocation, classic Java way
<3> Constructor usage, using coercion with `as` keyword
<4> Constructor usage, using coercion in assignment

==== Named parameters

If no (or a no-arg) constructor is declared, it is possible to create objects by passing parameters in the form of a
map (property/value pairs). This can be in handy in cases where one wants to allow several combinations of parameters.
Otherwise, by using traditional positional parameters it would be necessary to declare all possible constructors.
Having a constructor where the first (and perhaps only) argument is a `Map` argument is also supported - such a
constructor may also be added using the gapi:groovy.transform.MapConstructor[] annotation.

[source,groovy]
----
include::../test/ClassTest.groovy[tags=constructor_named_parameters,indent=0]
----
<1> No constructor declared
<2> No parameters given in the instantiation
<3> `name` parameter given in the instantiation
<4> `age` parameter given in the instantiation
<5> `name` and `age` parameters given in the instantiation

It is important to highlight, however, that this approach gives more power to the constructor caller,
while imposing an increased responsibility on the caller to get the names and value types correct.
Thus, if greater control is desired, declaring constructors using positional parameters might be preferred.

Notes:

* While the example above supplied no constructor, you can also supply a no-arg constructor
or a constructor where the first argument is a `Map`, most typically it's the only argument.
* When no (or a no-arg) constructor is declared, Groovy replaces the named constructor call by a call
to the no-arg constructor followed by calls to the setter for each supplied named property.
* When the first argument is a Map, Groovy combines all named parameters into a Map (regardless of ordering)
and supplies the map as the first parameter. This can be a good approach if your properties are declared as
`final` (since they will be set in the constructor rather than after the fact with setters).
* You can support both named and positional construction
by supply both positional constructors as well as a no-arg or Map constructor.
* You can support hybrid construction by having a constructor where the first argument
is a Map but there are also additional positional parameters. Use this style with caution.

=== Methods

Groovy methods are quite similar to other languages. Some peculiarities will be shown in the next subsections. 

==== Method definition

A method is defined with a return type or with the `def` keyword, to make the return type untyped. A method can also receive any number of arguments, which may not have their types explicitly declared. Java modifiers can be used normally, and if no visibility modifier is provided, the method is public.

Methods in Groovy always return some value. If no `return` statement is provided, the value evaluated in the last line executed will be returned. For instance, note that none of the following methods uses the `return` keyword.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=method_definition ,indent=0]
----
<1> Method with no return type declared and no parameter
<2> Method with explicit return type and no parameter
<3> Method with a parameter with no type defined
<4> Static method with a String parameter

==== Named parameters

Like constructors, normal methods can also be called with named parameters.
To support this notation, a convention is used where the first argument to the method is a `Map`.
In the method body, the parameter values can be accessed as in normal maps (`map.key`).
If the method has just a single Map argument, all supplied parameters must be named.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=named_arguments ,indent=0]
----

===== Mixing named and positional parameters

Named parameters can be mixed with positional parameters.
The same convention applies, in this case, in addition to the `Map` argument as the first argument,
the method in question will have additional positional arguments as needed.
Supplied positional parameters when calling the method must be in order.
The named parameters can be in any position. They are grouped into the map and supplied as
the first parameter automatically.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=named_arguments_with_additional_arguments ,indent=0]
----
<1> Method call with additional `number` argument of `Integer` type
<2> Method call with changed order of arguments


If we don't have the Map as the first argument, then a Map must be supplied for that argument instead of named parameters.
Failure to do so will lead to `groovy.lang.MissingMethodException`:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=failed_named_arguments_with_additional_arguments ,indent=0]
----
<1> Method call throws `groovy.lang.MissingMethodException: No signature of method: foo() is applicable for argument types: (LinkedHashMap, Integer) values: [[name:Marie, age:1], 23]`, because the named argument `Map` parameter is not defined as the first argument

Above exception can be avoided if we replace named arguments with an explicit `Map` argument:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=explicit_named_arguments_with_additional_arguments ,indent=0]
----
<1> Explicit `Map` argument in place of named arguments makes invocation valid

TIP: Although Groovy allows you to mix named and positional parameters, it can lead to unnecessary confusion.
Mix named and positional arguments with caution.

==== Default arguments

Default arguments make parameters optional. If the argument is not supplied, the method assumes a default value.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=default_arguments ,indent=0]
----

Note that no mandatory parameter can be defined after a default parameter is present, only other default parameters.

==== Varargs

Groovy supports methods with a variable number of arguments. They are defined like this: `def foo(p1, ..., pn, T... args)`.
Here `foo` supports `n` arguments by default, but also an unspecified number of further arguments exceeding `n`.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=varargs_example,indent=0]
----

This example defines a method `foo`, that can take any number of arguments, including no arguments at all.
`args.length` will return the number of arguments given. Groovy allows `T[]` as an alternative notation to `T...`.
That means any method with an array as last parameter is seen by Groovy as a method that can take a variable number of arguments.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=varargs_array_notation,indent=0]
----

If a method with varargs is called with `null` as the vararg parameter, then the argument will be `null` and not an array of length one with `null` as the only element.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=varargs_null_parameter,indent=0]
----

If a varargs method is called with an array as an argument, then the argument will be that array instead of an array of length one containing the given array as the only element.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=varargs_array_parameter,indent=0]
----

Another important point are varargs in combination with method overloading. In case of method overloading Groovy will select the most specific method.
For example if a method `foo` takes a varargs argument of type `T` and another method `foo` also takes one argument of type `T`, the second method is preferred.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=varargs_method_overloading,indent=0]
----

==== Method selection algorithm

Dynamic Groovy supports https://en.wikipedia.org/wiki/Multiple_dispatch[multiple dispatch] (aka multimethods).
When calling a method, the actual method invoked is determined
dynamically based on the run-time type of methods arguments.
First the method name and number of arguments will be considered (including allowance for varargs),
and then the type of each argument.
Consider the following method definitions:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=multi_methods,indent=0]
----

Perhaps as expected, calling `method` with `String` and `Integer` parameters,
invokes our third method definition.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=call_single_method,indent=0]
----

Of more interest here is when the types are not known at compile time.
Perhaps the arguments are declared to be of type `Object` (a list of such objects in our case).
Java would determine that the `method(Object, Object)` variant would be selected in all
cases (unless casts were used) but as can be seen in the following example, Groovy uses the runtime type
and will invoke each of our methods once (and normally, no casting is needed):

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=call_multi_methods,indent=0]
----

For each of the first two of our three method invocations an exact match of argument types was found.
For the third invocation, an exact match of `method(Integer, Integer)` wasn't found but `method(Object, Object)`
is still valid and will be selected.

Method selection then is about finding the _closest fit_ from valid method candidates which have compatible
parameter types.
So, `method(Object, Object)` is also valid for the first two invocations but is not as close a match
as the variants where types exactly match.
To determine the closest fit, the runtime has a notion of the _distance_ an actual argument
type is away from the declared parameter type and tries to minimise the total distance across all parameters.

The following table illustrates some factors which affect the distance calculation.

[cols=""1,1"" options=""header""]
|====
| Aspect
| Example

| Directly implemented interfaces match more closely than ones from further up the inheritance hierarchy.
a| Given these interface and method definitions:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=multi_method_distance_interfaces,indent=0]
----

The directly implemented interface will match:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=multi_method_distance_interfaces_usage,indent=0]
----

| An Object array is preferred over an Object.
a|
[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=object_array_over_object,indent=0]
----

| Non-vararg variants are favored over vararg variants.
a|
[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=non_varargs_over_vararg,indent=0]
----

| If two vararg variants are applicable, the one which uses the minimum number of vararg arguments is preferred.
a|
[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=minimal_varargs,indent=0]
----

| Interfaces are preferred over super classes.
a|
[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=multi_method_distance_interface_over_super,indent=0]
----

| For a primitive argument type, a declared parameter type which is the same or slightly larger is preferred.
a|
[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=primitive_larger_over_smaller,indent=0]
----
|====

In the case where two variants have exactly the same distance, this is deemed ambiguous and will cause a runtime exception:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=multi_method_ambiguous,indent=0]
----

Casting can be used to select the desired method:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=multi_method_ambiguous_cast,indent=0]
----


==== Exception declaration

Groovy automatically allows you to treat checked exceptions like unchecked exceptions.
This means that you don't need to declare any checked exceptions that a method may throw
as shown in the following example which can throw a `FileNotFoundException` if the file isn't found:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=idiomatic_method_declaration,indent=0]
----

Nor will you be required to surround the call to the `badRead` method in the previous example within a try/catch
block - though you are free to do so if you wish.

If you wish to declare any exceptions that your code might throw (checked or otherwise) you are free to do so.
Adding exceptions won't change how the code is used from any other Groovy code but can be seen as documentation
for the human reader of your code. The exceptions will become part of the method declaration in the bytecode,
so if your code might be called from Java, it might be useful to include them.
Using an explicit checked exception declaration is illustrated in the following example:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=checked_method_declaration,indent=0]
----

=== Fields and Properties

[[fields]]
==== Fields

A field is a member of a class or a trait which has:

* a mandatory _access modifier_ (`public`, `protected`, or `private`)
* one or more optional _modifiers_ (`static`, `final`, `synchronized`)
* an optional _type_
* a mandatory _name_

[source,groovy]
----
include::../test/ClassTest.groovy[tags=field_declaration,indent=0]
----
<1> a `private` field named `id`, of type `int`
<2> a `protected` field named `description`, of type `String`
<3> a `public static final` field named _DEBUG_ of type `boolean`

A field may be initialized directly at declaration:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=field_initialization,indent=0]
----
<1> the private field `id` is initialized with `IDGenerator.next()`

It is possible to omit the type declaration of a field. This is however considered a bad practice and in general it
is a good idea to use strong typing for fields:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=typing_fields,indent=0]
----
<1> the field `mapping` doesn't declare a type
<2> the field `mapping` has a strong type

The difference between the two is important if you want to use optional type checking later.
It is also important as a way to document the class design.
However, in some cases like scripting or if you want to rely on duck typing it may be useful
to omit the type.

[[properties]]
==== Properties

A property is an externally visible feature of a class. Rather than just using a public field to represent
such features (which provides a more limited abstraction and would restrict refactoring possibilities),
the typical approach in Java is to follow the conventions outlined in the
{javabeans}[JavaBeans Specification], i.e. represent the property using a
combination of a private backing field and getters/setters. Groovy follows these same conventions
but provides a simpler way to define the property. You can define a property with:

* an *absent* access modifier (no `public`, `protected` or `private`)
* one or more optional _modifiers_ (`static`, `final`, `synchronized`)
* an optional _type_
* a mandatory _name_

Groovy will then generate the getters/setters appropriately. For example:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=properties_definition,indent=0]
----
<1> creates a backing `private String name` field, a `getName` and a `setName` method
<2> creates a backing `private int age` field, a `getAge` and a `setAge` method

If a property is declared `final`, no setter is generated:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=readonly_property,indent=0]
----
<1> defines a read-only property of type `String`
<2> defines a read-only property of type `int`
<3> assigns the `name` parameter to the `name` field
<4> assigns the `age` parameter to the `age` field

Properties are accessed by name and will call the getter or setter transparently, unless the code is in the class
which defines the property:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=property_access,indent=0]
----
<1> `this.name` will directly access the field because the property is accessed from within the class that defines it
<2> similarily a read access is done directly on the `name` field
<3> write access to the property is done outside of the `Person` class so it will implicitly call `setName`
<4> read access to the property is done outside of the `Person` class so it will implicitly call `getName`
<5> this will call the `name` method on `Person` which performs a direct access to the field
<6> this will call the `title` method on `Person` which performs a direct read access to the field

It is worth noting that this behavior of accessing the backing field directly is done in order to prevent a stack
overflow when using the property access syntax within a class that defines the property.

It is possible to list the properties of a class thanks to the meta `properties` field of an instance:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=properties_meta,indent=0]
----

By convention, Groovy will recognize properties even if there is no backing field
provided there are getters or setters
that follow the Java Beans specification. For example:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=pseudo_properties,indent=0]
----
<1> writing `p.name` is allowed because there is a pseudo-property `name`
<2> reading `p.age` is allowed because there is a pseudo-readonly property `age`
<3> writing `p.groovy` is allowed because there is a pseudo-writeonly property `groovy`

This syntactic sugar is at the core of many DSLs written in Groovy.

===== Property naming conventions

It is generally recommended that the first two letters of a property name are
lowercase and for multi-word properties that camel case is used.
In those cases, generated getters and setters will have a name formed by capitalizing the
property name and adding a `get` or `set` prefix (or optionally ""is"" for a boolean getter).
So, `getLength` would be a getter  for a `length` property and `setFirstName` a setter for a `firstName` property.
`isEmpty` might be the getter method name for a property named `empty`.

[NOTE]
====
Property names starting with a capital letter would have getters/setters with just the prefix added.
So, the property `Foo` is allowed even though it isn't following the recommended naming conventions.
For this property, the accessor methods would be `setFoo` and `getFoo`.
A consequence of this is that you aren't allowed to have both a `foo` and a `Foo` property,
since they would have the same named accessor methods.
====

The JavaBeans specification makes a special case for properties which typically might be acronyms.
If the first two letters of a property name are uppercase, no capitalization is performed
(or more importantly, no decapitalization is done if generating the property name from the accessor method name).
So, `getURL` would be the getter for a `URL` property.

[NOTE]
====
Because of the special ""acronym handling"" property naming logic in the JavaBeans specification, the
conversion to and from a property name are non-symmetrical. This leads to some strange edge cases.
Groovy adopts a naming convention that avoids one ambiguity that might seem a little strange but
was popular at the time of Groovy's design and has remained (so far) for historical reasons.
Groovy looks at the second letter of a property name. If that is a capital, the property is deemed to be
one of the acronym style properties and no capitalization is done, otherwise normal capitalization is done.
Although we _never_ recommend it, it does allow you to have what might seem like ""duplicate named"" properties,
e.g. you can have `aProp` and `AProp`, or `pNAME` and `PNAME`. The getters would be `getaProp` and `getAProp`,
and `getpNAME` and `getPNAME` respectively.
====

===== Modifiers on a property

We have already seen that properties are defined by omitting the visibility modifier.
In general, any other modifiers, e.g. `transient` would be copied across to the field.
Two special cases are worth noting:

* `final`, which we saw earlier is for read-only properties, is copied onto the backing field but also causes no setter to be defined
* `static` is copied onto the backing field but also causes the accessor methods to be static

If you wish to have a modifier like `final` also carried over to the accessor methods,
you can write your properties long hand or consider using a <<split-properties,split property definition>>.

===== Annotations on a property

Annotations, including those associated with AST transforms,
are copied on to the backing field for the property.
This allows AST transforms which are applicable to fields to
be applied to properties, e.g.:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=annotated_properties,indent=0]
----
<1> Confirms no eager initialization
<2> Normal property access
<3> Confirms initialization upon property access

[[split-properties]]
===== Split property definition with an explicit backing field

Groovy's property syntax is a convenient shorthand when your class design
follows certain conventions which align with common JavaBean practice.
If your class doesn't exactly fit these conventions,
you can certainly write the getter, setter and backing field long hand like you would in Java.
However, Groovy does provide a split definition capability which still provides
a shortened syntax while allowing slight adjustments to the conventions.
For a split definition, you write a field and a property with the same name and type.
Only one of the field or property may have an initial value.

For split properties, annotations on the field remain on the backing field for the property.
Annotations on the property part of the definition are copied onto the getter and setter methods.

This mechanism allows a number of common variations that property users may wish
to use if the standard property definition doesn't exactly fit their needs.
For example, if the backing field should be `protected` rather than `private`:

[source,groovy]
----
class HasPropertyWithProtectedField {
    protected String name  // <1>
    String name            // <2>
}
----
<1> Protected backing field for name property instead of normal private one
<2> Declare name property

Or, the same example but with a package-private backing field:

[source,groovy]
----
class HasPropertyWithPackagePrivateField {
    String name                // <1>
    @PackageScope String name  // <2>
}
----
<1> Declare name property
<2> Package-private backing field for name property instead of normal private one

As a final example, we may wish to apply method-related AST transforms,
or in general, any annotation to the setters/getters,
e.g. to have the accessors be synchronized:

[source,groovy]
----
class HasPropertyWithSynchronizedAccessorMethods {
    private String name        // <1>
    @Synchronized String name  // <2>
}
----
<1> Backing field for name property
<2> Declare name property with annotation for setter/getter

===== Explicit accessor methods

The automatic generation of accessor methods doesn't occur if there
is an explicit definition of the getter or setter in the class.
This allows you to modify the normal behavior of such a getter or setter if needed.
Inherited accessor methods aren't normally considered but if an inherited
accessor method is marked final, that will also cause no generation of an
additional accessor method to honor the `final` requirement of no subclassing of such methods.

=== Annotation

[[ann-definition]]
==== Annotation definition

An annotation is a kind of special interface dedicated at annotating elements of the code. An annotation is a type which
superinterface is the jdk:java.lang.annotation.Annotation[Annotation] interface. Annotations are declared in a very
similar way to interfaces, using the `@interface` keyword:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=define_annotation,indent=0]
----

An annotation may define members in the form of methods without bodies and an optional default value. The possible
member types are limited to:

* primitive types
* jdk:java.lang.String[Strings]
* jdk:java.lang.Class[Classes]
* an jdk:java.lang.Enum[enumeration]
* another jdk:java.lang.annotation.Annotation[annotation type]
* or any array of the above

For example:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=ann_member_string,indent=0]
include::../test/ClassTest.groovy[tags=ann_member_string_default,indent=0]
include::../test/ClassTest.groovy[tags=ann_member_int,indent=0]
include::../test/ClassTest.groovy[tags=ann_member_class,indent=0]
include::../test/ClassTest.groovy[tags=ann_member_annotation,indent=0]
include::../test/ClassTest.groovy[tags=ann_member_enum,indent=0]
----
<1> an annotation defining a `value` member of type `String`
<2> an annotation defining a `value` member of type `String` with a default value of `something`
<3> an annotation defining a `step` member of type the primitive type `int`
<4> an annotation defining a `appliesTo` member of type `Class`
<5> an annotation defining a `value` member which type is an array of another annotation type
<6> an annotation defining a `dayOfWeek` member which type is the enumeration type `DayOfWeek`

Unlike in the Java language, in Groovy, an annotation can be used to alter the semantics of the language. It is especially
true of AST transformations which will generate code based on annotations.

[[ann-placement]]
==== Annotation placement

An annotation can be applied on various elements of the code:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=apply_annotation_1,indent=0]
----
<1> `@SomeAnnotation` applies to the `someMethod` method
<2> `@SomeAnnotation` applies to the `SomeClass` class
<3> `@SomeAnnotation` applies to the `var` variable

In order to limit the scope where an annotation can be applied, it is necessary to declare it on the annotation
definition, using the jdk:java.lang.annotation.Target[Target] annotation. For example, here is how you would
declare that an annotation can be applied to a class or a method:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=ann_target,indent=0]
----
<1> the `@Target` annotation is meant to annotate an annotation with a scope.
<2> `@SomeAnnotation` will therefore only be allowed on `TYPE` or `METHOD`

The list of possible targets is available in the jdk:java.lang.annotation.ElementType[ElementType enumeration].

WARNING: Groovy does not support the jdk:java.lang.annotation.ElementType#TYPE_PARAMETER[TYPE_PARAMETER] and
jdk:java.lang.annotation.ElementType#TYPE_PARAMETER[TYPE_USE] element types which were introduced in Java 8.

==== Annotation member values

When an annotation is used, it is required to set at least all members that do not have a default value. For example:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=annotation_value_set,indent=0]
----

However it is possible to omit `value=` in the declaration of the value of an annotation if the member `value` is the
only one being set:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=annotation_value_set_option,indent=0]
----
<1> we can omit the `statusCode` because it has a default value, but `value` needs to be set
<2> since `value` is the only mandatory member without a default, we can omit `value=`
<3> if both `value` and `statusCode` need to be set, it is required to use `value=` for the default `value` member

==== Retention policy

The visibility of an annotation depends on its retention policy. The retention policy of an annotation is set using
the jdk:java.lang.annotation.Retention[Retention] annotation:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=ann_retention,indent=0]
----
<1> the `@Retention` annotation annotates the `@SomeAnnotation` annotation
<2> so `@SomeAnnotation` will have a `SOURCE` retention

The list of possible retention targets and description is available in the
jdk:java.lang.annotation.RetentionPolicy[RetentionPolicy] enumeration. The
choice usually depends on whether you want an annotation to be visible at
compile time or runtime.

==== Closure annotation parameters

An interesting feature of annotations in Groovy is that you can use a closure as an annotation value. Therefore
annotations may be used with a wide variety of expressions and still have IDE support. For example, imagine a
framework where you want to execute some methods based on environmental constraints like the JDK version or the OS.
One could write the following code:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=closure_ann_example,indent=0]
----

For the `@OnlyIf` annotation to accept a `Closure` as an argument, you only have to declare the `value` as a `Class`:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=closure_ann_def,indent=0]
----

To complete the example, let's write a sample runner that would use that information:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=closure_ann_runner,indent=0]
----
<1> create a new instance of the class passed as an argument (the task class)
<2> emulate an environment which is JDK 6 and not Windows
<3> iterate on all declared methods of the task class
<4> if the method is public and takes no-argument
<5> try to find the `@OnlyIf` annotation
<6> if it is found get the `value` and create a new `Closure` out of it
<7> set the `delegate` of the closure to our environment variable
<8> call the closure, which is the annotation closure. It will return a `boolean`
<9> if it is `true`, call the method
<10> if the method is not annotated with `@OnlyIf`, execute the method anyway
<11> after that, return the task object

Then the runner can be used this way:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=closure_ann_runner_exec,indent=0]
----

==== Meta-annotations

===== Declaring meta-annotations

Meta-annotations, also known as annotation aliases are annotations that
are replaced at compile time by other annotations (one meta-annotation
is an alias for one or more annotations). Meta-annotations can be used to
reduce the size of code involving multiple annotations.

Let’s start with a simple example. Imagine you have the `@Service`
and `@Transactional` annotations and that you want to annotate a class
with both:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=transactionalservice_class,indent=0]
----

Given the multiplication of annotations that you could add to the same class, a meta-annotation
could help by reducing the two annotations with a single one having the very same semantics. For example,
we might want to write this instead:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=transactionalservice_class2,indent=0]
----
<1> `@TransactionalService` is a meta-annotation

A meta-annotation is declared as a regular annotation but annotated with `@AnnotationCollector` and the
list of annotations it is collecting. In our case, the `@TransactionalService` annotation can be written:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=metaann_ts,indent=0]
----
<1> annotate the meta-annotation with `@Service`
<2> annotate the meta-annotation with `@Transactional`
<3> annotate the meta-annotation with `@AnnotationCollector`

[[meta-ann-behavior]]
===== Behavior of meta-annotations

Groovy supports both _precompiled_ and _source form_
meta-annotations. This means that your meta-annotation _may_ be
precompiled, or you can have it in the same source tree as the one you
are currently compiling.

INFO: Meta-annotations are a Groovy-only feature. There is
no chance for you to annotate a Java class with a meta-annotation and
hope it will do the same as in Groovy. Likewise, you cannot write a
meta-annotation in Java: both the meta-annotation definition *and* usage
have to be Groovy code. But you can happily collect Java annotations
and Groovy annotations within your meta-annotation.

When the Groovy compiler encounters a class annotated with a
meta-annotation, it *replaces* it with the collected annotations. So,
in our previous example, it will
replace `@TransactionalService` with `@Transactional` and `@Service`:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=annotations_expanded,indent=0]
----

The conversion from a meta-annotation to the collected annotations is performed during the
_semantic analysis_ compilation phase. 

In addition to replacing the alias with the collected annotations, a meta-annotation is capable of
processing them, including arguments.

[[meta-ann-members]]
===== Meta-annotation parameters

Meta-annotations can collect annotations which have parameters. To illustrate this,
we will imagine two annotations, each of them accepting one argument:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=collected_ann_explosive,indent=0]
----

And suppose that you want create a meta-annotation named `@Explosive`:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=collected_ann_explosive,indent=0]
include::../test/ClassTest.groovy[tags=collector_ann_explosive,indent=0]
----

By default, when the annotations are replaced, they will get the
annotation parameter values *as they were defined in the alias*. More interesting,
the meta-annotation supports overriding specific values:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=example_bomb,indent=0]
----
<1> the `after` value provided as a parameter to `@Explosive` overrides the one defined in the `@Timeout` annotation

If two annotations define the same parameter name, the default processor
will copy the annotation value to all annotations that accept this parameter:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=collector_ann_same_values,indent=0]
----
<1> the `@Foo` annotation defines the `value` member of type `String`
<2> the `@Bar` annotation also defines the `value` member of type `String`
<3> the `@FooBar` meta-annotation aggregates `@Foo` and `@Bar`
<4> class `Bob` is annotated with `@Foo` and `@Bar`
<5> the value of the `@Foo` annotation on `Bob` is `a`
<6> while the value of the `@Bar` annotation on `Bob` is `b`
<7> class `Joe` is annotated with `@FooBar`
<8> then the value of the `@Foo` annotation on `Joe` is `a`
<9> and the value of the `@Bar` annotation on `Joe` is also `a`

In the second case, the meta-annotation value was copied in
both `@Foo` and `@Bar` annotations.

WARNING: It is a compile time error if the collected annotations define the same members
with incompatible types. For example if on the previous example `@Foo` defined a value of
type `String` but `@Bar` defined a value of type `int`.

It is however possible to customize the behavior of meta-annotations and describe how collected
annotations are expanded. We'll look at how to do that shortly but first there is an advanced
processing option to cover.

[[handling_duplicate_annotations]]
===== Handling duplicate annotations

The `@AnnotationCollector` annotation supports a `mode` parameter which can be used to
alter how the default processor handles annotation replacement in the presence of
duplicate annotations.

INFO: Custom processors (discussed next) may or may not support this parameter.

As an example, suppose you create a meta-annotation containing the `@ToString` annotation
and then place your meta-annotation on a class that already has an explicit `@ToString`
annotation. Should this be an error? Should both annotations be applied? Does one take
priority over the other? There is no correct answer. In some scenarios it might be
quite appropriate for any of these answers to be correct. So, rather than trying to
preempt one correct way to handle the duplicate annotation issue, Groovy let's you
write your own custom meta-annotation processors (covered next) and let's you write
whatever checking logic you like within AST transforms - which are a frequent target for
aggregating. Having said that, by simply setting the `mode`, a number of commonly
expected scenarios are handled automatically for you within any extra coding.
The behavior of the `mode` parameter is determined by the `AnnotationCollectorMode`
enum value chosen and is summarized in the following table.

|================================
| Mode | Description
| DUPLICATE | Annotations from the annotation collection will always be inserted. After all transforms have been run, it will be an error if multiple annotations (excluding those with SOURCE retention) exist.
| PREFER_COLLECTOR | Annotations from the collector will be added and any existing annotations with the same name will be removed.
| PREFER_COLLECTOR_MERGED | Annotations from the collector will be added and any existing annotations with the same name will be removed but any new parameters found within existing annotations will be merged into the added annotation.
| PREFER_EXPLICIT | Annotations from the collector will be ignored if any existing annotations with the same name are found.
| PREFER_EXPLICIT_MERGED | Annotations from the collector will be ignored if any existing annotations with the same name are found but any new parameters on the collector annotation will be added to existing annotations.
|================================

[[meta-ann-processor]]
===== Custom annotation processors

A custom annotation processor will let you choose how to expand a
meta-annotation into collected annotations. The behaviour of the meta-annotation is,
in this case, totally up to you. To do this, you must:

* create a meta-annotation processor, extending gapi:org.codehaus.groovy.transform.AnnotationCollectorTransform[AnnotationCollectorTransform]
* declare the processor to be used in the meta-annotation declaration

To illustrate this, we are going to explore how the meta-annotation `@CompileDynamic` is implemented.

`@CompileDynamic` is a meta-annotation that expands itself
to `@CompileStatic(TypeCheckingMode.SKIP)`. The problem is that the
default meta annotation processor doesn’t support enums and the
annotation value `TypeCheckingMode.SKIP` is one.

The naive implementation here would not work:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=compiledynamic_naive,indent=0]
----

Instead, we will define it like this:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=compiledynamic_def_fixed,indent=0]
----

The first thing you may notice is that our interface is no longer
annotated with `@CompileStatic`. The reason for this is that we rely on
the `processor` parameter instead, that references a class which
will *generate* the annotation.

Here is how the custom processor is implemented:

[source,groovy]
.CompileDynamicProcessor.groovy
----
include::../test/ClassTest.groovy[tags=compiledynamic_processor,indent=0]
----
<1> our custom processor is written in Groovy, and for better compilation performance, we use static compilation
<2> the custom processor has to extend gapi:org.codehaus.groovy.transform.AnnotationCollectorTransform[AnnotationCollectorTransform]
<3> create a class node representing the `@CompileStatic` annotation type
<4> create a class node representing the `TypeCheckingMode` enum type
<5> `collector` is the `@AnnotationCollector` node found in the meta-annotation. Usually unused.
<6> `aliasAnnotationUsage` is the meta-annotation being expanded, here it is `@CompileDynamic`
<7> `aliasAnnotated` is the node being annotated with the meta-annotation
<8> `sourceUnit` is the `SourceUnit` being compiled
<9> we create a new annotation node for `@CompileStatic`
<10> we create an expression equivalent to `TypeCheckingMode.SKIP`
<11> we add that expression to the annotation node, which is now `@CompileStatic(TypeCheckingMode.SKIP)`
<12> return the generated annotation

In the example, the `visit` method is the only method which has to be overridden. It is meant to return a list of
annotation nodes that will be added to the node annotated with the meta-annotation. In this example, we return a
single one corresponding to `@CompileStatic(TypeCheckingMode.SKIP)`.

[[generics]]
=== Generics

(TBD)


include::_traits.adoc[leveloffset=+1]

include::_records.adoc[leveloffset=+1]

include::_sealed.adoc[leveloffset=+1]
",12202,False,2082.4722901175805,median
"//------------------------------------------------------------------------------
//
//   Copyright 2018-2020 Fetch.AI Limited
//
//   Licensed under the Apache License, Version 2.0 (the ""License"");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       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 ""gmock/gmock.h""
#include ""vm_modules/math/tensor/tensor.hpp""
#include ""vm_modules/math/type.hpp""
#include ""vm_modules/ml/dataloaders/dataloader.hpp""
#include ""vm_test_toolkit.hpp""

#include <regex>
#include <sstream>

using namespace fetch::vm;

namespace {

using DataType = fetch::vm_modules::math::DataType;

std::string const ADD_INVALID_LAYER_TEST_SOURCE = R""(
    function main()
      var model = Model(""sequential"");
      <<TOKEN>>
    endfunction
  )"";

std::string const ADD_VALID_LAYER_TEST_SOURCE = R""(
    function main()
      var model = Model(""sequential"");
      <<TOKEN>>
      model.compile(""scel"", ""adam"");
    endfunction
  )"";

std::string const ACTIVATION_LAYER_TEST_SOURCE = R""(
     function main() : Tensor
         var model = Model(""sequential"");
         model.add(""activation"", ""<<ACTIVATION>>"");
         model.compile(""mse"", ""sgd"");

         var x = Tensor();

         x.fromString(""<<INPUT>>"");

         var activated = model.predict(x);

         return activated;
     endfunction
)"";

constexpr bool IGNORE_CHARGE_ESTIMATION = true;

class VMModelTests : public ::testing::Test
{
public:
  std::stringstream stdout;
  VmTestToolkit     toolkit{&stdout};

  void TestValidLayerAdding(std::string const &test_case_source,
                            bool               ignore_charge_estimation = false)
  {
    std::string const src =
        std::regex_replace(ADD_VALID_LAYER_TEST_SOURCE, std::regex(""<<TOKEN>>""), test_case_source);
    ASSERT_TRUE(toolkit.Compile(src));
    if (ignore_charge_estimation)
    {
      ASSERT_TRUE(toolkit.Run(nullptr, ChargeAmount{0}));
    }
    else
    {
      ASSERT_TRUE(toolkit.Run());
    }
  }

  void TestInvalidLayerAdding(std::string const &test_case_source)
  {
    std::string const src = std::regex_replace(ADD_INVALID_LAYER_TEST_SOURCE,
                                               std::regex(""<<TOKEN>>""), test_case_source);
    ASSERT_TRUE(toolkit.Compile(src));
    // Invalid layer adding parameters (activation, layer type, parameter values) must not cause
    // unhandled exception/runtime crash, but should raise VM RuntimeError and cause a safe stop.
    ASSERT_FALSE(toolkit.Run());
  }

  void TestAddingUncompilableLayer(std::string const &test_case_source)
  {
    std::string const src = std::regex_replace(ADD_INVALID_LAYER_TEST_SOURCE,
                                               std::regex(""<<TOKEN>>""), test_case_source);
    // Wrong number of arguments in layer adding parameters or calling uncompatible "".compile()""
    // method for a model must end in model compilation error and safe stop.
    ASSERT_FALSE(toolkit.Compile(src));
  }

  void TestActivation(std::string const &input, std::string const &activation,
                      std::string const &expected)
  {
    std::string src =
        std::regex_replace(ACTIVATION_LAYER_TEST_SOURCE, std::regex(""<<ACTIVATION>>""), activation);
    src = std::regex_replace(src, std::regex(""<<INPUT>>""), input);
    ASSERT_TRUE(toolkit.Compile(src));
    Variant res;
    ASSERT_TRUE(toolkit.Run(&res, ChargeAmount{0}));

    auto const gt =
        fetch::math::Tensor<fetch::vm_modules::math::DataType>::FromString(expected.c_str());

    auto const prediction = res.Get<Ptr<fetch::vm_modules::math::VMTensor>>();

    bool const passed = (prediction->GetTensor()).AllClose(gt);
    if (!passed)
    {
      std::cout << ""Expected: "" << gt.ToString() << std::endl;
      std::cout << "" Result : "" << prediction->ToString()->string() << std::endl;
    }

    EXPECT_TRUE(passed);
  }
};  // namespace

TEST_F(VMModelTests, serialisation_model)
{
  static char const *model_serialise_src = R""(

      function build_model() : Model
        var model = Model(""sequential"");
        model.add(""dense"", 10u64, 10u64, ""relu"");
        model.add(""dense"", 10u64, 10u64, ""relu"");
        model.add(""dense"", 10u64, 1u64);
        return model;
      endfunction

      function main()

        // set up data and labels
        var data_shape = Array<UInt64>(2);
        data_shape[0] = 10u64;
        data_shape[1] = 250u64;
        var label_shape = Array<UInt64>(2);
        label_shape[0] = 1u64;
        label_shape[1] = 250u64;
        var data = Tensor(data_shape);
        var label = Tensor(label_shape);

        // set up a model
        var model1 = build_model();
        var model2 = build_model();
        var model3 = build_model();
        var model4 = build_model();

        // compile the models with different optimisers and loss functions
        model1.compile(""mse"", ""sgd"");
        model2.compile(""cel"", ""sgd"");
        model3.compile(""mse"", ""adam"");
        model4.compile(""cel"", ""adam"");

        // train the models
        model1.fit(data, label, 32u64);
        model2.fit(data, label, 32u64);
        model3.fit(data, label, 32u64);
        model4.fit(data, label, 32u64);

        // evaluate performance
        var loss1 = model1.evaluate();
        var loss2 = model2.evaluate();
        var loss3 = model3.evaluate();
        var loss4 = model4.evaluate();

        // make a prediction
        var prediction1 = model1.predict(data);
        var prediction2 = model2.predict(data);
        var prediction3 = model3.predict(data);
        var prediction4 = model4.predict(data);

        // serialise model
        var model_state1 = State<Model>(""model1"");
        var model_state2 = State<Model>(""model2"");
        var model_state3 = State<Model>(""model3"");
        var model_state4 = State<Model>(""model4"");
        model_state1.set(model1);
        model_state2.set(model2);
        model_state3.set(model3);
        model_state4.set(model4);

      endfunction
    )"";

  std::string const model_name1{""model1""};
  std::string const model_name2{""model2""};
  std::string const model_name3{""model3""};
  std::string const model_name4{""model4""};

  ASSERT_TRUE(toolkit.Compile(model_serialise_src));
  EXPECT_CALL(toolkit.observer(), Write(model_name1, _, _));
  EXPECT_CALL(toolkit.observer(), Write(model_name2, _, _));
  EXPECT_CALL(toolkit.observer(), Write(model_name3, _, _));
  EXPECT_CALL(toolkit.observer(), Write(model_name4, _, _));
  ASSERT_TRUE(toolkit.Run());

  static char const *model_deserialise_src = R""(
      function main()
        var model_state1 = State<Model>(""model1"");
        var model_state2 = State<Model>(""model2"");
        var model_state3 = State<Model>(""model3"");
        var model_state4 = State<Model>(""model4"");
        var model1 = model_state1.get();
        var model2 = model_state2.get();
        var model3 = model_state3.get();
        var model4 = model_state4.get();
      endfunction
    )"";

  ASSERT_TRUE(toolkit.Compile(model_deserialise_src));
  EXPECT_CALL(toolkit.observer(), Exists(model_name1));
  EXPECT_CALL(toolkit.observer(), Exists(model_name2));
  EXPECT_CALL(toolkit.observer(), Exists(model_name3));
  EXPECT_CALL(toolkit.observer(), Exists(model_name4));
  EXPECT_CALL(toolkit.observer(), Read(model_name1, _, _)).Times(::testing::Between(1, 2));
  EXPECT_CALL(toolkit.observer(), Read(model_name2, _, _)).Times(::testing::Between(1, 2));
  EXPECT_CALL(toolkit.observer(), Read(model_name3, _, _)).Times(::testing::Between(1, 2));
  EXPECT_CALL(toolkit.observer(), Read(model_name4, _, _)).Times(::testing::Between(1, 2));
  ASSERT_TRUE(toolkit.Run());
}

TEST_F(VMModelTests, model_string_serialisation_test)
{
  static char const *graph_serialise_src = R""(

      function build_model() : Model
        var model = Model(""sequential"");
        model.add(""dense"", 10u64, 10u64, ""relu"");
        model.add(""dense"", 10u64, 10u64, ""relu"");
        model.add(""dense"", 10u64, 1u64);
        return model;
      endfunction

      function main()

        // set up data and labels
        var data_shape = Array<UInt64>(2);
        data_shape[0] = 10u64;
        data_shape[1] = 250u64;
        var label_shape = Array<UInt64>(2);
        label_shape[0] = 1u64;
        label_shape[1] = 250u64;
        var data = Tensor(data_shape);
        var label = Tensor(label_shape);

        // set up a model
        var model1 = build_model();
        var model2 = build_model();
        var model3 = build_model();
        var model4 = build_model();
        // compile the models with different optimisers and loss functions
        model1.compile(""mse"", ""sgd"");
        model2.compile(""cel"", ""sgd"");
        model3.compile(""mse"", ""adam"");
        model4.compile(""cel"", ""adam"");

        // train the models
        model1.fit(data, label, 32u64);
        model2.fit(data, label, 32u64);
        model3.fit(data, label, 32u64);
        model4.fit(data, label, 32u64);

        // evaluate performance
        var loss1 = model1.evaluate();
        var loss2 = model2.evaluate();
        var loss3 = model3.evaluate();
        var loss4 = model4.evaluate();

        // make a prediction
        var prediction1 = model1.predict(data);
        var prediction2 = model2.predict(data);
        var prediction3 = model3.predict(data);
        var prediction4 = model4.predict(data);

       // serialise to string
        var model_string_1 = model1.serializeToString();
        var model_string_2 = model2.serializeToString();
        var model_string_3 = model3.serializeToString();
        var model_string_4 = model4.serializeToString();

        var state1 = State<String>(""model_state1"");
        var state2 = State<String>(""model_state2"");
        var state3 = State<String>(""model_state3"");
        var state4 = State<String>(""model_state4"");

        state1.set(model_string_1);
        state2.set(model_string_2);
        state3.set(model_string_3);
        state4.set(model_string_4);

      endfunction
  )"";

  std::string const state_name1{""model_state1""};
  std::string const state_name2{""model_state2""};
  std::string const state_name3{""model_state3""};
  std::string const state_name4{""model_state4""};
  ASSERT_TRUE(toolkit.Compile(graph_serialise_src));
  EXPECT_CALL(toolkit.observer(), Write(state_name1, _, _));
  EXPECT_CALL(toolkit.observer(), Write(state_name2, _, _));
  EXPECT_CALL(toolkit.observer(), Write(state_name3, _, _));
  EXPECT_CALL(toolkit.observer(), Write(state_name4, _, _));
  ASSERT_TRUE(toolkit.Run());

  static char const *graph_deserialise_src = R""(
    function main()
      var state1 = State<String>(""model_state1"");
      var state2 = State<String>(""model_state2"");
      var state3 = State<String>(""model_state3"");
      var state4 = State<String>(""model_state4"");

      var model_string1 = state1.get();
      var model_string2 = state2.get();
      var model_string3 = state3.get();
      var model_string4 = state4.get();

      var model1 = Model(""none"");
      var model2 = Model(""none"");
      var model3 = Model(""none"");
      var model4 = Model(""none"");
      model1 = model1.deserializeFromString(model_string1);
      model2 = model2.deserializeFromString(model_string2);
      model3 = model3.deserializeFromString(model_string3);
      model4 = model4.deserializeFromString(model_string4);

    endfunction
  )"";

  ASSERT_TRUE(toolkit.Compile(graph_deserialise_src));
  EXPECT_CALL(toolkit.observer(), Exists(state_name1));
  EXPECT_CALL(toolkit.observer(), Exists(state_name2));
  EXPECT_CALL(toolkit.observer(), Exists(state_name3));
  EXPECT_CALL(toolkit.observer(), Exists(state_name4));
  EXPECT_CALL(toolkit.observer(), Read(state_name1, _, _)).Times(::testing::Between(1, 2));
  EXPECT_CALL(toolkit.observer(), Read(state_name2, _, _)).Times(::testing::Between(1, 2));
  EXPECT_CALL(toolkit.observer(), Read(state_name3, _, _)).Times(::testing::Between(1, 2));
  EXPECT_CALL(toolkit.observer(), Read(state_name4, _, _)).Times(::testing::Between(1, 2));
  ASSERT_TRUE(toolkit.Run());
}

TEST_F(VMModelTests, non_permitted_serialisation_model_sequential_test)
{
  static char const *model_sequential_serialise_src = R""(

      function main()

        // set up a model
        var model = Model(""sequential"");
        model.add(""dense"", 10u64, 10u64, ""relu"");
        model.add(""dense"", 10u64, 10u64, ""relu"");
        model.add(""dense"", 10u64, 1u64);

        // serialise model
        var model_state = State<Model>(""model"");
        model_state.set(model);

      endfunction
    )"";

  ASSERT_TRUE(toolkit.Compile(model_sequential_serialise_src));
  EXPECT_FALSE(toolkit.Run());
}

TEST_F(VMModelTests, model_init_with_wrong_name)
{
  static char const *SRC_CORRECT_NAMES = R""(
        function main()
          var model1 = Model(""sequential"");
          var model4 = Model(""none"");
        endfunction
      )"";
  ASSERT_TRUE(toolkit.Compile(SRC_CORRECT_NAMES));
  EXPECT_TRUE(toolkit.Run());

  static char const *SRC_WRONG_NAME = R""(
      function main()
        var model = Model(""wrong_name"");
      endfunction
    )"";
  ASSERT_TRUE(toolkit.Compile(SRC_WRONG_NAME));
  EXPECT_FALSE(toolkit.Run());
}

TEST_F(VMModelTests, model_add_dense_noact)
{
  TestValidLayerAdding(R""(model.add(""dense"", 10u64, 10u64);)"");
}

TEST_F(VMModelTests, model_add_dense_relu)
{
  TestValidLayerAdding(R""(model.add(""dense"", 10u64, 10u64, ""relu"");)"");
}

TEST_F(VMModelTests, model_add_conv1d_noact)
{
  TestValidLayerAdding(R""(model.add(""conv1d"", 10u64, 10u64, 10u64, 10u64);)"",
                       IGNORE_CHARGE_ESTIMATION);
}

TEST_F(VMModelTests, model_add_conv1d_relu)
{
  TestValidLayerAdding(R""(model.add(""conv1d"", 10u64, 10u64, 10u64, 10u64, ""relu"");)"",
                       IGNORE_CHARGE_ESTIMATION);
}

TEST_F(VMModelTests, model_add_conv2d_noact)
{
  TestValidLayerAdding(R""(model.add(""conv2d"", 10u64, 10u64, 10u64, 10u64);)"",
                       IGNORE_CHARGE_ESTIMATION);
}

TEST_F(VMModelTests, model_add_conv2d_relu)
{
  TestValidLayerAdding(R""(model.add(""conv2d"", 10u64, 10u64, 10u64, 10u64, ""relu"");)"",
                       IGNORE_CHARGE_ESTIMATION);
}

TEST_F(VMModelTests, model_add_dropout)
{
  TestValidLayerAdding(R""(model.add(""dropout"", 0.256fp64);)"", IGNORE_CHARGE_ESTIMATION);
}

TEST_F(VMModelTests, model_add_flatten)
{
  TestValidLayerAdding(R""(model.add(""flatten"");)"", IGNORE_CHARGE_ESTIMATION);
}

TEST_F(VMModelTests, model_add_activation)
{
  TestValidLayerAdding(R""(model.add(""activation"", ""relu"");)"", IGNORE_CHARGE_ESTIMATION);
  TestValidLayerAdding(R""(model.add(""activation"", ""leaky_relu"");)"", IGNORE_CHARGE_ESTIMATION);
  TestValidLayerAdding(R""(model.add(""activation"", ""gelu"");)"", IGNORE_CHARGE_ESTIMATION);
  TestValidLayerAdding(R""(model.add(""activation"", ""sigmoid"");)"", IGNORE_CHARGE_ESTIMATION);
  TestValidLayerAdding(R""(model.add(""activation"", ""log_sigmoid"");)"", IGNORE_CHARGE_ESTIMATION);
  TestValidLayerAdding(R""(model.add(""activation"", ""softmax"");)"", IGNORE_CHARGE_ESTIMATION);
  TestValidLayerAdding(R""(model.add(""activation"", ""log_softmax"");)"", IGNORE_CHARGE_ESTIMATION);
}

TEST_F(VMModelTests, model_add_input)
{
  TestValidLayerAdding(R""(
                       var data_shape = Array<UInt64>(2);
                       data_shape[0] = 10u64;
                       data_shape[1] = 250u64;
                       model.addExperimental(""input"", data_shape);
                       model.add(""activation"", ""softmax"");)"",
                       IGNORE_CHARGE_ESTIMATION);
}

TEST_F(VMModelTests, model_add_invalid_layer_type)
{
  TestInvalidLayerAdding(R""(model.add(""INVALID_LAYER_TYPE"", 1u64, 1u64);)"");
}

TEST_F(VMModelTests, model_add_dense_invalid_params_noact)
{
  TestInvalidLayerAdding(R""(model.add(""dense"", 1u64, 1u64, 1u64, 1u64);)"");
}

TEST_F(VMModelTests, model_add_dense_invalid_params_relu)
{
  TestInvalidLayerAdding(R""(model.add(""dense"", 1u64, 1u64, 1u64, 1u64, ""relu"");)"");
}

TEST_F(VMModelTests, model_add_conv_invalid_params_noact)
{
  TestInvalidLayerAdding(R""(model.add(""conv1d"", 10u64, 10u64);)"");
}

TEST_F(VMModelTests, model_add_conv_invalid_params_relu)
{
  TestInvalidLayerAdding(R""(model.add(""conv1d"", 10u64, 10u64, ""relu"");)"");
}

TEST_F(VMModelTests, model_add_activation_invalid_params)
{
  TestInvalidLayerAdding(R""(model.add(""activation"", ""UNKNOWN_ACTIVATION"");)"");
}

TEST_F(VMModelTests, model_add_layers_invalid_activation_dense)
{
  TestInvalidLayerAdding(R""(model.add(""dense"", 10u64, 10u64, ""INVALID_ACTIVATION_DENSE"");)"");
}

TEST_F(VMModelTests, model_add_dropout_invalid_params)
{
  TestInvalidLayerAdding(R""(model.add(""dropout"", 10fp64);)"");
}

TEST_F(VMModelTests, model_add_reshape_invalid_params)
{
  TestInvalidLayerAdding(R""(model.add(""reshape"", 10fp64);)"");
}

TEST_F(VMModelTests, model_add_layers_invalid_activation_conv)
{
  TestInvalidLayerAdding(
      R""(model.add(""conv1d"", 1u64, 1u64, 1u64, 1u64, ""INVALID_ACTIVATION_CONV"");)"");
}

TEST_F(VMModelTests, model_uncompilable_add_layer__dense_uncompatible_params)
{
  TestAddingUncompilableLayer(R""(model.add(""dense"", 10u64, 10u64, 10u64, ""relu"");)"");
}

TEST_F(VMModelTests, model_uncompilable_add_layer__conv_uncompatible_params)
{
  TestAddingUncompilableLayer(R""(model.add(""conv1d"", 10u64, 10u64, 10u64, ""relu"");)"");
}

TEST_F(VMModelTests, model_uncompilable_add_layer__dense_invalid_params)
{
  TestAddingUncompilableLayer(R""(model.add(""dense"", 10fp32, 10u64, ""relu"");)"");
}

TEST_F(VMModelTests, model_uncompilable_add_layer__flatten_invalid_params)
{
  TestAddingUncompilableLayer(R""(model.add(""flatten"", 10fp32);)"");
}

TEST_F(VMModelTests, model_uncompilable_add_layer__conv_invalid_params)
{
  TestAddingUncompilableLayer(R""(model.add(""conv1d"", 0u64, 10fp32, 10u64, 10u64, ""relu"");)"");
}

TEST_F(VMModelTests, model_uncompilable_add_layer__dropout_invalid_params)
{
  TestAddingUncompilableLayer(R""(model.add(""dropout"", 0u64);)"");
}

TEST_F(VMModelTests, model_uncompilable_add_layer__reshape_invalid_params)
{
  TestAddingUncompilableLayer(R""(model.add(""reshape"", 1u64);)"");
}

TEST_F(VMModelTests, model_uncompilable_add_layer__activation_invalid_params)
{
  TestAddingUncompilableLayer(R""(model.add(""activation"", 0u64);)"");
}

TEST_F(VMModelTests, model_uncompilable_add_layer__input_invalid_params)
{
  TestAddingUncompilableLayer(R""(model.add(""input"", 0u64);)"");
}

TEST_F(VMModelTests, model_empty_sequential_compilation)
{
  static char const *EMPTY_SEQUENTIAL_SRC = R""(
      function main()
         var model = Model(""sequential"");
         model.compile(""mse"", ""sgd"");
      endfunction
    )"";

  ASSERT_TRUE(toolkit.Compile(EMPTY_SEQUENTIAL_SRC));
  std::cout << ""Testing compilation of an empty Sequential model"" << std::endl;
  EXPECT_FALSE(toolkit.Run());
}

TEST_F(VMModelTests, model_compilation_invalid_params)
{
  static char const *SEQUENTIAL_SRC = R""(
      function main()
         var model = Model(""sequential"");
         model.add(""dense"", 10u64, 1u64);
         <<TOKEN>>
      endfunction
    )"";

  static char const *INVALID_LOSS      = R""(model.compile(""INVALID_LOSS"", ""adam"");)"";
  static char const *INVALID_OPTIMIZER = R""(model.compile(""mse"", ""INVALID_OPTIMIZER"");)"";
  static char const *INVALID_BOTH      = R""(model.compile(""INVALID_LOSS"", ""INVALID_OPTIMIZER"");)"";

  for (auto const &test_case : {INVALID_LOSS, INVALID_OPTIMIZER, INVALID_BOTH})
  {
    std::cout << ""Testing invalid model compilation params: "" << test_case << std::endl;
    std::string const src = std::regex_replace(SEQUENTIAL_SRC, std::regex(""<<TOKEN>>""), test_case);
    ASSERT_TRUE(toolkit.Compile(src));
    EXPECT_FALSE(toolkit.Run());
  }
}

// Disableduntil AddDropout estimator implementation
TEST_F(VMModelTests, model_dropout_comparison)
{
  static char const *SOURCE = R""(
    function main()
        var dropouted_model = Model(""sequential"");
        dropouted_model.add(""dropout"", 0.1fp64);
        dropouted_model.compile(""mse"", ""adam"");

        var reference_model = Model(""sequential"");
        // Dropout with probability 0 acts as a simple connection
        // between input layers and output layer; this workaround is needed
        // because a sequential model with direct connection of inputs to
        // outputs can not be compiled.
        reference_model.add(""dropout"", 0.0fp64);
        reference_model.compile(""mse"", ""adam"");

        var shape = Array<UInt64>(3);
        shape[0] = 25u64;
        shape[1] = 25u64;
        shape[2] = 1u64;
        var x = Tensor(shape);

        x.fillRandom();

        var y = x.copy();
        y += y;

        var old_ref_loss = 0.0fp64;
        for (i in 0:5)
            dropouted_model.fit(x, y, 10u64);
            reference_model.fit(x, y, 10u64);
            var new_loss = dropouted_model.evaluate();
            var new_ref_loss = reference_model.evaluate();

            if (old_ref_loss == 0.0fp64)
              old_ref_loss = new_ref_loss[0];
            endif
            assert(new_ref_loss[0] == old_ref_loss, ""Model corrupts input data!"");
            assert(new_loss[0] != new_ref_loss[0], ""Dropout did not change a layer output during training!"");
        endfor

    endfunction
    )"";

  ASSERT_TRUE(toolkit.Compile(SOURCE));
  EXPECT_TRUE(toolkit.Run(nullptr, ChargeAmount{0}));
}

TEST_F(VMModelTests, dense_sequential_model_test)
{
  static char const *sequential_model_src = R""(
    function main()

      // set up data and labels
      var data_shape = Array<UInt64>(2);
      data_shape[0] = 10u64;
      data_shape[1] = 250u64;
      var label_shape = Array<UInt64>(2);
      label_shape[0] = 1u64;
      label_shape[1] = 250u64;
      var data = Tensor(data_shape);
      var label = Tensor(label_shape);

      // set up a model
      var model = Model(""sequential"");
      model.add(""dense"", 10u64, 10u64, ""relu"");
      model.add(""dense"", 10u64, 10u64, ""relu"");
      model.add(""dense"", 10u64, 1u64);
      model.compile(""mse"", ""adam"");

      // train the model
      model.fit(data, label, 32u64);

      // make a prediction
      var loss = model.evaluate();
    endfunction
  )"";

  ASSERT_TRUE(toolkit.Compile(sequential_model_src));
  ASSERT_TRUE(toolkit.Run());
}

TEST_F(VMModelTests, conv1d_sequential_model_test)
{
  static char const *sequential_model_src = R""(
    function main() : Tensor

      // conv1d parameters
      var input_channels  = 3u64;
      var output_channels = 5u64;
      var input_height    = 3u64;
      var kernel_size     = 3u64;
      var output_height   = 1u64;
      var stride_size     = 1u64;

      // set up input data tensor
      var data_shape = Array<UInt64>(3);
      data_shape[0] = input_channels;
      data_shape[1] = input_height;
      data_shape[2] = 1u64;
      var data = Tensor(data_shape);
      for (in_channel in 0u64:input_channels)
        for (in_height in 0u64:input_height)
          data.setAt(in_channel, in_height, 0u64, toFixed64(in_height + 1u64));
        endfor
      endfor

      // set up a gt label tensor
      var label_shape = Array<UInt64>(3);
      label_shape[0] = output_channels;
      label_shape[1] = output_height;
      label_shape[2] = 1u64;
      var label = Tensor(label_shape);

      // set up a model
      var model = Model(""sequential"");
      model.add(""conv1d"", output_channels, input_channels, kernel_size, stride_size);
      model.compile(""mse"", ""adam"");

      // make an initial prediction
      var prediction = model.predict(data);

      // train the model
      model.fit(data, label, 1u64);

      // evaluate performance
      var loss = model.evaluate();

      return prediction;
    endfunction
  )"";

  Variant res;
  ASSERT_TRUE(toolkit.Compile(sequential_model_src));
  ASSERT_TRUE(toolkit.Run(&res, ChargeAmount{0}));
  auto const prediction = res.Get<Ptr<fetch::vm_modules::math::VMTensor>>();

  fetch::math::Tensor<fetch::vm_modules::math::DataType> gt({5, 1});
  gt(0, 0) = fetch::math::Type<DataType>(""+4.592834088"");
  gt(1, 0) = fetch::math::Type<DataType>(""-1.145004561"");
  gt(2, 0) = fetch::math::Type<DataType>(""+1.795713195"");
  gt(3, 0) = fetch::math::Type<DataType>(""+2.958410677"");
  gt(4, 0) = fetch::math::Type<DataType>(""+3.157947287"");
  // the actual model output is {5, 1, 1}
  ASSERT_TRUE((prediction->GetTensor())
                  .AllClose(gt, fetch::math::function_tolerance<DataType>(),
                            fetch::math::function_tolerance<DataType>()));
}

TEST_F(VMModelTests, conv2d_sequential_model_test)
{
  static char const *sequential_model_src = R""(
    function main() : Tensor

      // conv1d parameters
      var input_channels  = 3u64;
      var output_channels = 5u64;
      var input_height    = 3u64;
      var input_width     = 3u64;
      var kernel_size     = 3u64;
      var output_height   = 1u64;
      var output_width    = 1u64;
      var stride_size     = 1u64;

      // set up input data tensor
      var data_shape = Array<UInt64>(4);
      data_shape[0] = input_channels;
      data_shape[1] = input_height;
      data_shape[2] = input_width;
      data_shape[3] = 1u64;
      var data = Tensor(data_shape);
      for (in_channel in 0u64:input_channels)
        for (in_height in 0u64:input_height)
          for (in_width in 0u64:input_width)
            data.setAt(in_channel, in_height, in_width, 0u64, toFixed64(in_height * in_width + 1u64));
          endfor
        endfor
      endfor

      // set up a gt label tensor
      var label_shape = Array<UInt64>(4);
      label_shape[0] = output_channels;
      label_shape[1] = output_height;
      label_shape[2] = output_width;
      label_shape[3] = 1u64;
      var label = Tensor(label_shape);

      // set up a model
      var model = Model(""sequential"");
      model.add(""conv2d"", output_channels, input_channels, kernel_size, stride_size);
      model.compile(""mse"", ""adam"");

      // make an initial prediction
      var prediction = model.predict(data);

      // train the model
      model.fit(data, label, 1u64);

      // evaluate performance
      var loss = model.evaluate();

      return prediction;
    endfunction
  )"";

  Variant res;
  ASSERT_TRUE(toolkit.Compile(sequential_model_src));
  ASSERT_TRUE(toolkit.Run(&res, ChargeAmount{0}));
  auto const prediction = res.Get<Ptr<fetch::vm_modules::math::VMTensor>>();

  fetch::math::Tensor<fetch::vm_modules::math::DataType> gt({5, 1});
  gt(0, 0) = fetch::math::Type<DataType>(""+3.924331061"");
  gt(1, 0) = fetch::math::Type<DataType>(""+6.421101891"");
  gt(2, 0) = fetch::math::Type<DataType>(""-0.231269899"");
  gt(3, 0) = fetch::math::Type<DataType>(""+7.779843630"");
  gt(4, 0) = fetch::math::Type<DataType>(""+10.291701029"");
  // the actual model output is {5, 1, 1, 1}
  ASSERT_TRUE((prediction->GetTensor())
                  .AllClose(gt, fetch::math::function_tolerance<DataType>(),
                            fetch::math::function_tolerance<DataType>()));
}

TEST_F(VMModelTests, model_with_metric)
{
  static char const *SRC_METRIC = R""(
        function main() : Array<Fixed64>
          // set up data and labels
          var data_shape = Array<UInt64>(2);
          data_shape[0] = 10u64;
          data_shape[1] = 250u64;
          var label_shape = Array<UInt64>(2);
          label_shape[0] = 1u64;
          label_shape[1] = 250u64;
          var data = Tensor(data_shape);
          var label = Tensor(label_shape);

          // set up model
          var model = Model(""sequential"");
          model.add(""dense"", 10u64, 10u64, ""relu"");
          model.add(""dense"", 10u64, 10u64, ""relu"");
          model.add(""dense"", 10u64, 1u64);
          model.compile(""mse"", ""adam"", {""mse""});

          // train the model
          model.fit(data, label, 32u64);

          // evaluate
          var mets = model.evaluate();
          return mets;
        endfunction
      )"";

  ASSERT_TRUE(toolkit.Compile(SRC_METRIC));
  Variant res;
  EXPECT_TRUE(toolkit.Run(&res));

  auto const metrics = res.Get<Ptr<Array<fetch::vm_modules::math::DataType>>>();
  EXPECT_EQ(metrics->elements.at(0), metrics->elements.at(1));
}

TEST_F(VMModelTests, model_with_accuracy_metric)
{
  static char const *SRC_METRIC = R""(
        function main() : Array<Fixed64>
          // set up data and labels
          var data_shape = Array<UInt64>(2);
          data_shape[0] = 10u64;
          data_shape[1] = 250u64;
          var label_shape = Array<UInt64>(2);
          label_shape[0] = 7u64;
          label_shape[1] = 250u64;
          var data = Tensor(data_shape);
          var label = Tensor(label_shape);

          // set up model
          var model = Model(""sequential"");
          model.add(""dense"", 10u64, 10u64, ""relu"");
          model.add(""dense"", 10u64, 10u64, ""relu"");
          model.add(""dense"", 10u64, 7u64);
          model.compile(""scel"", ""adam"", {""categorical accuracy""});

          // train the model
          model.fit(data, label, 32u64);

          // evaluate
          var mets = model.evaluate();
          return mets;
        endfunction
      )"";

  ASSERT_TRUE(toolkit.Compile(SRC_METRIC));

  Variant res;
  ASSERT_TRUE(toolkit.Run(&res));

  auto const metrics = res.Get<Ptr<Array<fetch::vm_modules::math::DataType>>>();
  EXPECT_GE(metrics->elements.at(1), DataType{0});
  EXPECT_LE(metrics->elements.at(1), DataType{1});
}

TEST_F(VMModelTests, model_sequential_flatten)
{
  static char const *SRC_METRIC = R""(
        function main()
          var model = Model(""sequential"");
          model.add(""flatten"");
          model.compile(""scel"", ""adam"", {""categorical accuracy""});
        endfunction
      )"";

  ASSERT_TRUE(toolkit.Compile(SRC_METRIC));
  ASSERT_TRUE(toolkit.Run(nullptr, ChargeAmount{0}));
}

TEST_F(VMModelTests, model_sequential_reshape)
{
  static char const *SRC_METRIC = R""(
        function main()
          var shape = Array<UInt64>(3);
          shape[0] = 3u64;
          shape[1] = 2u64;
          shape[2] = 1u64;
          var model = Model(""sequential"");
          model.add(""reshape"", shape);
          model.compile(""scel"", ""adam"", {""categorical accuracy""});
        endfunction
      )"";

  ASSERT_TRUE(toolkit.Compile(SRC_METRIC));
  ASSERT_TRUE(toolkit.Run(nullptr, ChargeAmount{0}));
}

TEST_F(VMModelTests, model_sequential_flatten_tensor_data)
{
  static char const *SRC_METRIC = R""(
        function main() : Tensor
          var x = Tensor();
          var str_vals = ""0.5, 7.1, 9.1; 6.2, 7.1, 4.; -99.1, 14328.1, 10.0;"";
          x.fromString(str_vals);
          var data = x.unsqueeze();

          var model = Model(""sequential"");
          model.add(""flatten"");
          model.compile(""scel"", ""adam"", {""categorical accuracy""});
          var prediction = model.predict(data);
          print(prediction.toString());

          return prediction;
        endfunction
      )"";

  Variant res;
  ASSERT_TRUE(toolkit.Compile(SRC_METRIC));
  ASSERT_TRUE(toolkit.Run(&res, ChargeAmount{0}));
  // we expect data columns to be sequentially concatenated
  ASSERT_EQ(stdout.str(),
            ""0.500000000;""
            ""6.199999999;""
            ""-99.099999999;""
            ""7.099999999;""
            ""7.099999999;""
            ""14328.099999999;""
            ""9.099999999;""
            ""4.000000000;""
            ""10.000000000;"");
  auto const tensor            = res.Get<Ptr<fetch::vm_modules::math::VMTensor>>();
  auto const constructed_shape = tensor->shape();
  fetch::math::Tensor<fetch::fixed_point::fp64_t> expected({9, 1});
  EXPECT_TRUE(constructed_shape == expected.shape());
}

TEST_F(VMModelTests, model_sequential_flatten_2d_in_2d_out)
{
  static char const *SRC_METRIC = R""(
              function main() : Tensor
                var x = Tensor();
                var str_vals = ""0.5, 7.1, 9.1; 6.2, 7.1, 4.;"";
                x.fromString(str_vals);

                var model = Model(""sequential"");
                model.add(""flatten"");
                model.compile(""scel"", ""adam"");
                var prediction = model.predict(x);
                print(prediction.toString());

                return prediction;
              endfunction
      )"";

  Variant res;
  ASSERT_TRUE(toolkit.Compile(SRC_METRIC));
  ASSERT_TRUE(toolkit.Run(&res, ChargeAmount{0}));
  ASSERT_EQ(stdout.str(),
            ""0.500000000, 7.099999999, 9.099999999;""
            ""6.199999999, 7.099999999, 4.000000000;"");
  auto const tensor            = res.Get<Ptr<fetch::vm_modules::math::VMTensor>>();
  auto const constructed_shape = tensor->shape();
  fetch::math::Tensor<fetch::fixed_point::fp64_t> expected({2, 3});
  EXPECT_TRUE(constructed_shape == expected.shape());
}

TEST_F(VMModelTests, model_sequential_reshape_2d_in_2d_out)
{
  static char const *SRC_METRIC = R""(
          function main() : Tensor
                          var x = Tensor();
                          var str_vals = ""0.5; 7.1; 9.1; 6.2;"";
                          x.fromString(str_vals);

                          var to_shape = Array<UInt64>(2);
                          to_shape[0] = 4u64;
                          to_shape[1] = 1u64;

                          var model = Model(""sequential"");
                          model.add(""reshape"", to_shape);
                          model.compile(""scel"", ""adam"");
                          var prediction = model.predict(x);

                          return prediction;
          endfunction
      )"";

  Variant res;
  ASSERT_TRUE(toolkit.Compile(SRC_METRIC));
  ASSERT_TRUE(toolkit.Run(&res, ChargeAmount{0}));
  auto const prediction        = res.Get<Ptr<fetch::vm_modules::math::VMTensor>>();
  auto const constructed_shape = prediction->shape();

  fetch::math::Tensor<fetch::vm_modules::math::DataType> gt({4, 1});
  gt(0, 0) = fetch::math::Type<DataType>(""+0.5"");
  gt(1, 0) = fetch::math::Type<DataType>(""+7.1"");
  gt(2, 0) = fetch::math::Type<DataType>(""+9.1"");
  gt(3, 0) = fetch::math::Type<DataType>(""+6.2"");
  ASSERT_TRUE((prediction->GetTensor())
                  .AllClose(gt, fetch::math::function_tolerance<DataType>(),
                            fetch::math::function_tolerance<DataType>()));
  EXPECT_TRUE(constructed_shape == gt.shape());
}

TEST_F(VMModelTests, model_sequential_reshape_2d_in_2d_out_wrong_shape)
{
  static char const *SRC_METRIC = R""(
          function main() : Tensor
                          var x = Tensor();
                          var str_vals = ""0.5; 7.1; 9.1; 6.2;"";
                          x.fromString(str_vals);

                          var to_shape = Array<UInt64>(2);
                          to_shape[0] = 1u64;
                          to_shape[1] = 4u64;

                          var model = Model(""sequential"");
                          model.add(""reshape"", to_shape);
                          model.compile(""scel"", ""adam"");
                          var prediction = model.predict(x);

                          return prediction;
          endfunction
      )"";

  ASSERT_TRUE(toolkit.Compile(SRC_METRIC));
  ASSERT_FALSE(toolkit.Run(nullptr, ChargeAmount{0}));
}

TEST_F(VMModelTests, model_sequential_reshape_3d_in_2d_out)
{
  static char const *SRC_METRIC = R""(
              function main() : Tensor
                var x = Tensor();
                var str_vals = ""0.5, 7.1, 9.1; 6.2, 7.1, 4.;"";
                x.fromString(str_vals);
                x = x.unsqueeze();
                var to_shape = Array<UInt64>(2);
                to_shape[0] = 6u64;
                to_shape[1] = 1u64;

                var model = Model(""sequential"");
                model.add(""reshape"", to_shape);
                model.compile(""scel"", ""adam"");
                var prediction = model.predict(x);
                print(prediction.toString());

                return prediction;
              endfunction
      )"";

  Variant res;
  ASSERT_TRUE(toolkit.Compile(SRC_METRIC));
  ASSERT_TRUE(toolkit.Run(&res, ChargeAmount{0}));

  auto const prediction        = res.Get<Ptr<fetch::vm_modules::math::VMTensor>>();
  auto const constructed_shape = prediction->shape();

  fetch::math::Tensor<fetch::vm_modules::math::DataType> gt({6, 1});
  gt(0, 0) = fetch::math::Type<DataType>(""+0.5"");
  gt(1, 0) = fetch::math::Type<DataType>(""+6.2"");
  gt(2, 0) = fetch::math::Type<DataType>(""+7.1"");
  gt(3, 0) = fetch::math::Type<DataType>(""+7.1"");
  gt(4, 0) = fetch::math::Type<DataType>(""+9.1"");
  gt(5, 0) = fetch::math::Type<DataType>(""+4.0"");

  ASSERT_TRUE((prediction->GetTensor())
                  .AllClose(gt, fetch::math::function_tolerance<DataType>(),
                            fetch::math::function_tolerance<DataType>()));
  EXPECT_TRUE(constructed_shape == gt.shape());
}

TEST_F(VMModelTests, model_sequential_reshape_2d_in_3d_out)
{
  static char const *SRC_METRIC = R""(
          function main() : Tensor
                          var x = Tensor();
                          var str_vals = ""0.5; 7.1; 9.1; 6.2;"";
                          x.fromString(str_vals);

                          var to_shape = Array<UInt64>(3);
                          to_shape[0] = 2u64;
                          to_shape[1] = 2u64;
                          to_shape[2] = 1u64;

                          var model = Model(""sequential"");
                          model.add(""reshape"", to_shape);
                          model.compile(""scel"", ""adam"");
                          var prediction = model.predict(x);

                          return prediction;
          endfunction
      )"";

  Variant res;
  ASSERT_TRUE(toolkit.Compile(SRC_METRIC));
  ASSERT_TRUE(toolkit.Run(&res, ChargeAmount{0}));
  auto const prediction        = res.Get<Ptr<fetch::vm_modules::math::VMTensor>>();
  auto const constructed_shape = prediction->shape();

  fetch::math::Tensor<fetch::vm_modules::math::DataType> gt({2, 2});
  gt(0, 0) = fetch::math::Type<DataType>(""+0.5"");
  gt(1, 0) = fetch::math::Type<DataType>(""+7.1"");
  gt(0, 1) = fetch::math::Type<DataType>(""+9.1"");
  gt(1, 1) = fetch::math::Type<DataType>(""+6.2"");
  // the actual model output is {2, 2, 1}
  ASSERT_TRUE((prediction->GetTensor())
                  .AllClose(gt, fetch::math::function_tolerance<DataType>(),
                            fetch::math::function_tolerance<DataType>()));
  fetch::math::Tensor<fetch::fixed_point::fp64_t> expected({2, 2, 1});
  EXPECT_TRUE(constructed_shape == expected.shape());
}

TEST_F(VMModelTests, model_sequential_reshape_5d_in_3d_out)
{
  static char const *SRC_METRIC = R""(
          function main() : Tensor
                          var x = Tensor();
                          var str_vals = ""0.5; 7.1; 9.1; 6.2;"";
                          x.fromString(str_vals);
                          x = x.unsqueeze();
                          x = x.unsqueeze();
                          x = x.unsqueeze();

                          var to_shape = Array<UInt64>(3);
                          to_shape[0] = 2u64;
                          to_shape[1] = 2u64;
                          to_shape[2] = 1u64;

                          var model = Model(""sequential"");
                          model.add(""reshape"", to_shape);
                          model.compile(""scel"", ""adam"");
                          var prediction = model.predict(x);

                          return prediction;
          endfunction
      )"";

  Variant res;
  ASSERT_TRUE(toolkit.Compile(SRC_METRIC));
  ASSERT_TRUE(toolkit.Run(&res, ChargeAmount{0}));
  auto const prediction        = res.Get<Ptr<fetch::vm_modules::math::VMTensor>>();
  auto const constructed_shape = prediction->shape();

  fetch::math::Tensor<fetch::vm_modules::math::DataType> gt({2, 2});
  gt(0, 0) = fetch::math::Type<DataType>(""+0.5"");
  gt(1, 0) = fetch::math::Type<DataType>(""+7.1"");
  gt(0, 1) = fetch::math::Type<DataType>(""+9.1"");
  gt(1, 1) = fetch::math::Type<DataType>(""+6.2"");
  // the actual model output is {2, 2, 1}
  ASSERT_TRUE((prediction->GetTensor())
                  .AllClose(gt, fetch::math::function_tolerance<DataType>(),
                            fetch::math::function_tolerance<DataType>()));
  fetch::math::Tensor<fetch::fixed_point::fp64_t> expected({2, 2, 1});
  EXPECT_TRUE(constructed_shape == expected.shape());
}

TEST_F(VMModelTests, model_sequential_reshape_2d_in_8d_out)
{
  static char const *SRC_METRIC = R""(
          function main() : Tensor
                          var x = Tensor();
                          var str_vals = ""0.5; 7.1; 8.0999; 6.2;"";
                          x.fromString(str_vals);

                          var to_shape = Array<UInt64>(8);
                          to_shape[0] = 2u64;
                          to_shape[1] = 2u64;
                          to_shape[2] = 1u64;
                          to_shape[3] = 1u64;
                          to_shape[4] = 1u64;
                          to_shape[5] = 1u64;
                          to_shape[6] = 1u64;
                          to_shape[7] = 1u64;

                          var model = Model(""sequential"");
                          model.add(""reshape"", to_shape);
                          model.compile(""scel"", ""adam"");
                          var prediction = model.predict(x);

                          return prediction;
          endfunction
      )"";

  Variant res;
  ASSERT_TRUE(toolkit.Compile(SRC_METRIC));
  ASSERT_TRUE(toolkit.Run(&res, ChargeAmount{0}));
  auto const prediction        = res.Get<Ptr<fetch::vm_modules::math::VMTensor>>();
  auto const constructed_shape = prediction->shape();

  fetch::math::Tensor<fetch::vm_modules::math::DataType> gt({2, 2});
  gt(0, 0) = fetch::math::Type<DataType>(""+0.5"");
  gt(1, 0) = fetch::math::Type<DataType>(""+7.1"");
  gt(0, 1) = fetch::math::Type<DataType>(""+8.0999"");
  gt(1, 1) = fetch::math::Type<DataType>(""+6.2"");
  ASSERT_TRUE((prediction->GetTensor())
                  .AllClose(gt, fetch::math::function_tolerance<DataType>(),
                            fetch::math::function_tolerance<DataType>()));
  fetch::math::Tensor<fetch::fixed_point::fp64_t> expected({2, 2, 1, 1, 1, 1, 1, 1});
  EXPECT_TRUE(constructed_shape == expected.shape());
}

TEST_F(VMModelTests, model_sequential_flatten_4d_in_2d_out)
{
  static char const *SRC_METRIC = R""(
              function main() : Tensor
                var x = Tensor();
                var str_vals = ""0.5, 7.1, 9.1; 6.2, 7.1, 4.;"";
                x.fromString(str_vals);
                x = x.unsqueeze();
                x = x.unsqueeze();

                var model = Model(""sequential"");
                model.add(""flatten"");
                model.compile(""scel"", ""adam"");
                var prediction = model.predict(x);
                print(prediction.toString());

                return prediction;
              endfunction
      )"";

  Variant res;
  ASSERT_TRUE(toolkit.Compile(SRC_METRIC));
  ASSERT_TRUE(toolkit.Run(&res, ChargeAmount{0}));
  ASSERT_EQ(stdout.str(),
            ""0.500000000;""
            ""6.199999999;""
            ""7.099999999;""
            ""7.099999999;""
            ""9.099999999;""
            ""4.000000000;"");
  auto const tensor            = res.Get<Ptr<fetch::vm_modules::math::VMTensor>>();
  auto const constructed_shape = tensor->shape();
  fetch::math::Tensor<fetch::fixed_point::fp64_t> expected({6, 1});
  EXPECT_TRUE(constructed_shape == expected.shape());
}

TEST_F(VMModelTests, model_sequential_activation_layer_relu)
{
  std::string const input = ""-1000.0, -10.0, -1.0, -0.1, -0.0001; 0.0, 0.0001, 0.1, 1.0, 1000.0;"";
  std::string const activation = ""relu"";
  std::string const result     = ""0.0,   0.0,  0.0,  0.0,     0.0; 0.0, 0.0001, 0.1, 1.0, 1000.0;"";

  TestActivation(input, activation, result);
}

TEST_F(VMModelTests, model_sequential_activation_layer_leaky_relu)
{
  std::string const input = ""-1000.0, -10.0, -1.0, -0.1, -0.0001; 0.0, 0.0001, 0.1, 1.0, 1000.0;"";
  std::string const activation = ""leaky_relu"";
  std::string const result =
      ""-9.999999776, -0.099999997, -0.009999999, -0.001000000, -0.000001000; 0.000000000, ""
      ""0.000099999, 0.099999999, 1.000000000, 1000.000000000"";
  TestActivation(input, activation, result);
}

TEST_F(VMModelTests, model_sequential_activation_layer_sigmoid)
{
  std::string const input = ""-1000.0, -10.0, -1.0, -0.1, -0.0001; 0.0, 0.0001, 0.1, 1.0, 1000.0;"";
  std::string const activation = ""sigmoid"";
  std::string const result =
      ""0.0, 0.000045398, 0.268941422, 0.475020813, 0.499975; 0.5, 0.500025, ""
      ""0.524979188, 0.731058579, 0.999999999"";
  TestActivation(input, activation, result);
}

TEST_F(VMModelTests, model_sequential_activation_layer_log_sigmoid)
{
  std::string const input      = ""1000.0, 10.0, 1.0, 0.1, 0.0001; 0.0, 0.0001, 0.1, 1.0, 1000.0;"";
  std::string const activation = ""log_sigmoid"";
  std::string const result =
      ""0.000000000, -0.000045421, -0.313261687, -0.644396660, -0.693097181;-0.693147203, ""
      ""-0.693097181, -0.644396660, -0.313261687, 0.000000000;"";
  TestActivation(input, activation, result);
}

TEST_F(VMModelTests, model_sequential_activation_layer_softmax)
{
  std::string const input = ""-1000.0, -10.0, -1.0, -0.1, -0.0001; 0.0, 0.0001, 0.1, 1.0, 1000.0;"";
  std::string const activation = ""softmax"";
  std::string const result =
      ""0.000000000, 0.000045393, 0.249739894, 0.249739894, 0.000000000;0.999999999, 0.999954606, ""
      ""0.750260105, 0.750260105, 0.999999999;"";
  TestActivation(input, activation, result);
}

TEST_F(VMModelTests, model_sequential_activation_layer_log_softmax)
{
  std::string const input      = ""11.0, 12.0, 13.0, 14.0, 15.0; 16.0, 17.0, 18.0, 19.0, 10.0"";
  std::string const activation = ""log_softmax"";
  std::string const result =
      ""-4.451914411, -3.451914400, -2.451914397, -1.451914403, -0.451914395; -3.440269167, ""
      ""-2.440269163, -1.440269170, -0.440269160, -9.440271756;"";
  TestActivation(input, activation, result);
}

TEST_F(VMModelTests, model_sequential_activation_layer_gelu)
{
  std::string const input      = ""0.0, 1.0, 2.0, 3.0, 4.0; 0.0, -1.0, -2.0, -3.0, -4.0;"";
  std::string const activation = ""gelu"";
  std::string const result =
      ""0.000000000, 0.841191998, 1.954597482, 2.996362537, 3.999929750;0.000000000, -0.158808001, ""
      ""-0.045402517, -0.003637462, -0.000070249;"";
  TestActivation(input, activation, result);
}

TEST_F(VMModelTests, model_sequential_flatten_1d_in_2d_out)
{
  static char const *SRC_METRIC = R""(
              function main() : Tensor
                var shape = Array<UInt64>(1);
                shape[0] = 1u64;
                var x = Tensor(shape);

                var model = Model(""sequential"");
                model.add(""flatten"");
                model.compile(""scel"", ""adam"");
                var prediction = model.predict(x);
                print(prediction.toString());

                return prediction;
              endfunction
      )"";

  Variant res;
  ASSERT_TRUE(toolkit.Compile(SRC_METRIC));
  ASSERT_TRUE(toolkit.Run(&res, ChargeAmount{0}));
  ASSERT_EQ(stdout.str(), ""0.000000000;"");
  auto const tensor            = res.Get<Ptr<fetch::vm_modules::math::VMTensor>>();
  auto const constructed_shape = tensor->shape();
  fetch::math::Tensor<fetch::fixed_point::fp64_t> expected({1, 1});
  EXPECT_TRUE(constructed_shape == expected.shape());
}

TEST_F(VMModelTests, model_sequential_no_layers_with_metrics)
{
  static char const *SRC_METRIC = R""(
        function main() : Array<Fixed64>
          // set up data and labels
          var data_shape = Array<UInt64>(2);
          data_shape[0] = 10u64;
          data_shape[1] = 250u64;
          var label_shape = Array<UInt64>(2);
          label_shape[0] = 7u64;
          label_shape[1] = 250u64;
          var data = Tensor(data_shape);
          var label = Tensor(label_shape);

          // set up model
          var model = Model(""sequential"");
          model.compile(""scel"", ""adam"", {""categorical accuracy""});

          // train the model
          model.fit(data, label, 32u64);

          // evaluate
          var mets = model.evaluate();
          return mets;
        endfunction
      )"";

  ASSERT_TRUE(toolkit.Compile(SRC_METRIC));
  ASSERT_FALSE(toolkit.Run());
}

TEST_F(VMModelTests, model_sequential_no_layers)
{
  static char const *SEQUENTIAL_SRC = R""(
        function main()
          var model = Model(""sequential"");
          model.compile(""mse"", ""adam"");
        endfunction
    )"";

  ASSERT_TRUE(toolkit.Compile(SEQUENTIAL_SRC));
  EXPECT_FALSE(toolkit.Run());
}

TEST_F(VMModelTests, model_sequential_multiple_compile)
{
  static char const *SEQUENTIAL_SRC = R""(
        function main()
          var model = Model(""sequential"");
          model.add(""dense"", 10u64, 10u64, ""relu"");
          model.compile(""mse"", ""adam"");
          model.compile(""scel"", ""adam"");
          model.compile(""mse"", ""adam"");
        endfunction
    )"";

  ASSERT_TRUE(toolkit.Compile(SEQUENTIAL_SRC));
  EXPECT_FALSE(toolkit.Run());
}

TEST_F(VMModelTests, model_sequential_add_after_compile)
{
  static char const *SEQUENTIAL_SRC = R""(
      function main()
         var model = Model(""sequential"");
         model.add(""dense"", 10u64, 10u64, ""relu"");
         model.compile(""mse"", ""adam"");
         model.add(""dense"", 10u64, 1u64, ""relu"");
         model.compile(""mse"", ""adam"");
      endfunction
    )"";

  ASSERT_TRUE(toolkit.Compile(SEQUENTIAL_SRC));
  EXPECT_FALSE(toolkit.Run());
}

TEST_F(VMModelTests, model_sequential_predict_before_fit)
{
  static char const *SEQUENTIAL_SRC = R""(
      function main() : Array<Fixed64>
        // set up data and labels
        var data_shape = Array<UInt64>(2);
        data_shape[0] = 10u64;
        data_shape[1] = 250u64;
        var label_shape = Array<UInt64>(2);
        label_shape[0] = 7u64;
        label_shape[1] = 250u64;
        var data = Tensor(data_shape);
        var label = Tensor(label_shape);

        // set up model
        var model = Model(""sequential"");
        model.add(""dense"", 10u64, 10u64, ""relu"");
        model.add(""dense"", 10u64, 10u64, ""relu"");
        model.add(""dense"", 10u64, 7u64);
        model.compile(""scel"", ""adam"", {""categorical accuracy""});

        var prediction = model.predict(data);

        // train the model
        model.fit(data, label, 32u64);

        // evaluate performance
        var mets = model.evaluate();

        return mets;
      endfunction
    )"";

  ASSERT_TRUE(toolkit.Compile(SEQUENTIAL_SRC));
  ASSERT_TRUE(toolkit.Run());
}

TEST_F(VMModelTests, model_sequential_predict_bad_data)
{
  static char const *SEQUENTIAL_SRC = R""(
      function main()
        // set up malformed data tensor with shape 0,0
        var data_shape = Array<UInt64>(2);
        var data = Tensor(data_shape);

        // set up model
        var model = Model(""sequential"");
        model.add(""dense"", 10u64, 10u64, ""relu"");
        model.add(""dense"", 10u64, 10u64, ""relu"");
        model.add(""dense"", 10u64, 7u64);
        model.compile(""mse"", ""adam"", {""categorical accuracy""});

        var prediction = model.predict(data);
      endfunction
    )"";

  ASSERT_TRUE(toolkit.Compile(SEQUENTIAL_SRC));
  ASSERT_FALSE(toolkit.Run());
}

TEST_F(VMModelTests, model_sequential_evaluate_without_fit)
{
  static char const *SEQUENTIAL_SRC = R""(
      function main()
        // set up model
        var model = Model(""sequential"");
        model.add(""dense"", 10u64, 10u64, ""relu"");
        model.add(""dense"", 10u64, 10u64, ""relu"");
        model.add(""dense"", 10u64, 7u64);
        model.compile(""mse"", ""adam"", {""categorical accuracy""});

        var prediction = model.evaluate();
      endfunction
    )"";

  ASSERT_TRUE(toolkit.Compile(SEQUENTIAL_SRC));
  ASSERT_FALSE(toolkit.Run());
}

TEST_F(VMModelTests, model_sequential_fit_bad_data)
{
  static char const *SEQUENTIAL_SRC = R""(
      function main()
        // set up data and labels
        var data_shape = Array<UInt64>(2);
        var label_shape = Array<UInt64>(2);
        var data = Tensor(data_shape);
        var label = Tensor(label_shape);

        // set up model
        var model = Model(""sequential"");
        model.add(""dense"", 10u64, 10u64, ""relu"");
        model.add(""dense"", 10u64, 10u64, ""relu"");
        model.add(""dense"", 10u64, 7u64);
        model.compile(""scel"", ""adam"", {""categorical accuracy""});

        model.fit(data, label, 32u64);
      endfunction
    )"";

  ASSERT_TRUE(toolkit.Compile(SEQUENTIAL_SRC));
  ASSERT_FALSE(toolkit.Run());
}

TEST_F(VMModelTests, model_fit_and_refit)
{
  static char const *SRC_METRIC = R""(
        function main()
          // set up data and labels
          var data_shape = Array<UInt64>(2);
          data_shape[0] = 10u64;
          data_shape[1] = 250u64;
          var label_shape = Array<UInt64>(2);
          label_shape[0] = 7u64;
          label_shape[1] = 250u64;
          var data = Tensor(data_shape);
          var label = Tensor(label_shape);

          // set up model
          var model = Model(""sequential"");
          model.add(""dense"", 10u64, 10u64, ""relu"");
          model.add(""dense"", 10u64, 7u64);
          model.compile(""scel"", ""adam"");

          // train the model
          model.fit(data, label, 32u64);

          // new data and labels
          var data_shape2 = Array<UInt64>(2);
          data_shape2[0] = 10u64;
          data_shape2[1] = 123u64;
          var label_shape2 = Array<UInt64>(2);
          label_shape2[0] = 7u64;
          label_shape2[1] = 123u64;
          var data2 = Tensor(data_shape2);
          var label2 = Tensor(label_shape2);

          // train the model again
          model.fit(data2, label2, 16u64);

        endfunction
      )"";

  ASSERT_TRUE(toolkit.Compile(SRC_METRIC));

  ASSERT_TRUE(toolkit.Run());
}

TEST_F(VMModelTests, model_add_input_layer_as_second)
{
  static char const *SRC = R""(
      function main()
        var data_shape = Array<UInt64>(2);
        data_shape[0] = 10u64;
        data_shape[1] = 250u64;

        var model = Model(""sequential"");

        model.add(""dense"", 10u64, 10u64);
        model.addExperimental(""input"", data_shape);
      endfunction
    )"";

  ASSERT_TRUE(toolkit.Compile(SRC));
  ASSERT_FALSE(toolkit.Run(nullptr, ChargeAmount{0}));
}

TEST_F(VMModelTests, model_add_dense_auto_inputs)
{
  static char const *SRC = R""(
      function main()
        var data_shape = Array<UInt64>(4);
        data_shape[0] = 3u64;
        data_shape[1] = 3u64;
        data_shape[2] = 3u64;
        data_shape[3] = 25u64;

        var model = Model(""sequential"");

        model.addExperimental(""input"", data_shape);
        model.addExperimental(""dense"", 10u64);
        model.addExperimental(""dense"", 6u64);
        model.addExperimental(""dense"", 1u64);
        model.compile(""scel"", ""adam"");

        var data = Tensor(data_shape);
        data.fillRandom();
        model.predict(data);
      endfunction
    )"";

  ASSERT_TRUE(toolkit.Compile(SRC));
  ASSERT_TRUE(toolkit.Run(nullptr, ChargeAmount{0}));
}

TEST_F(VMModelTests, model_add_mixed_auto_inputs)
{
  static char const *SRC = R""(
      function main()
         var num_channels = 3u64;
         var image_height = 20u64;
         var image_width = 40u64;

         var data_shape = Array<UInt64>(4);
         data_shape[0] = num_channels;
         data_shape[1] = image_height;
         data_shape[2] = image_width;
         data_shape[3] = 25u64;

         var model = Model(""sequential"");

         model.addExperimental(""input"", data_shape);
         model.add(""conv2d"", num_channels, 13u64, 3u64, 1u64);
         model.add(""dropout"", 0.5fp64);
         model.add(""conv2d"", num_channels, 6u64, 3u64, 2u64);
         model.add(""activation"", ""sigmoid"");
         model.add(""conv2d"", num_channels, 3u64, 1u64, 2u64);
         model.add(""dropout"", 0.1fp64);
         model.addExperimental(""dense"", 6u64);
         model.addExperimental(""dense"", 1u64);
         model.compile(""scel"", ""adam"");

         var data = Tensor(data_shape);
         data.fillRandom();
         model.predict(data);
      endfunction
    )"";

  ASSERT_TRUE(toolkit.Compile(SRC));
  ASSERT_TRUE(toolkit.Run(nullptr, ChargeAmount{0}));
}

}  // namespace
",16224,True,4168.49948195435,median
" /*++
Copyright (c) 2017 Microsoft Corporation

Module Name:

    nla_core.cpp

Author:
    Lev Nachmanson (levnach)
    Nikolaj Bjorner (nbjorner)

--*/
#include ""math/lp/nla_core.h""
#include ""math/lp/factorization_factory_imp.h""
#include ""math/lp/nex.h""
#include ""math/grobner/pdd_solver.h""
#include ""math/dd/pdd_interval.h""
#include ""math/dd/pdd_eval.h""
namespace nla {

typedef lp::lar_term term;

core::core(lp::lar_solver& s, reslimit & lim) :
    m_evars(),
    m_lar_solver(s),
    m_tangents(this),
    m_basics(this),
    m_order(this),
    m_monotone(this),
    m_intervals(this, lim),
    m_monomial_bounds(this),
    m_horner(this),
    m_pdd_manager(s.number_of_vars()),
    m_pdd_grobner(lim, m_pdd_manager),
    m_emons(m_evars),
    m_reslim(lim),
    m_use_nra_model(false),
    m_nra(s, lim, *this)
{}
    
bool core::compare_holds(const rational& ls, llc cmp, const rational& rs) const {
    switch(cmp) {
    case llc::LE: return ls <= rs;
    case llc::LT: return ls < rs;
    case llc::GE: return ls >= rs;
    case llc::GT: return ls > rs;
    case llc::EQ: return ls == rs;
    case llc::NE: return ls != rs;
    default: SASSERT(false);
    };
        
    return false;
}

rational core::value(const lp::lar_term& r) const {
    rational ret(0);
    for (const auto & t : r) {
        ret += t.coeff() * val(t.column());
    }
    return ret;
}

lp::lar_term core::subs_terms_to_columns(const lp::lar_term& t) const {
    lp::lar_term r;
    for (const auto& p : t) {
        lpvar j = p.column();
        if (lp::tv::is_term(j))
            j = m_lar_solver.map_term_index_to_column_index(j);
        r.add_monomial(p.coeff(), j);
    }
    return r;
} 
    
bool core::ineq_holds(const ineq& n) const {
    return compare_holds(value(n.term()), n.cmp(), n.rs());
}

bool core::lemma_holds(const lemma& l) const {
    for(const ineq &i : l.ineqs()) {
        if (ineq_holds(i))
            return true;
    }
    return false;
}

lpvar core::map_to_root(lpvar j) const {
    return m_evars.find(j).var();
}
    
svector<lpvar> core::sorted_rvars(const factor& f) const {
    if (f.is_var()) {
        svector<lpvar> r; r.push_back(map_to_root(f.var()));
        return r;
    }
    return m_emons[f.var()].rvars();
}

// the value of the factor is equal to the value of the variable multiplied
// by the canonize_sign
bool core::canonize_sign(const factor& f) const {
    return f.sign() ^ (f.is_var()? canonize_sign(f.var()) : canonize_sign(m_emons[f.var()]));
}

bool core::canonize_sign(lpvar j) const {
    return m_evars.find(j).sign();        
}

bool core::canonize_sign_is_correct(const monic& m) const {
    bool r = false;
    for (lpvar j : m.vars()) {
        r ^= canonize_sign(j);
    }
    return r == m.rsign();
}

bool core::canonize_sign(const monic& m) const {
    SASSERT(canonize_sign_is_correct(m));
    return m.rsign();
}

bool core::canonize_sign(const factorization& f) const {
    bool r = false;
    for (const factor & a : f) {
        r ^= canonize_sign(a);
    }
    return r;
}

void core::add_monic(lpvar v, unsigned sz, lpvar const* vs) {
    m_add_buffer.resize(sz);
    for (unsigned i = 0; i < sz; i++) {
        lpvar j = vs[i];
        if (lp::tv::is_term(j))
            j = m_lar_solver.map_term_index_to_column_index(j);
        m_add_buffer[i] = j;
    }
    m_emons.add(v, m_add_buffer);
}
    
void core::push() {
    TRACE(""nla_solver_verbose"", tout << ""\\n"";);
    m_emons.push();
}

     
void core::pop(unsigned n) {
    TRACE(""nla_solver_verbose"", tout << ""n = "" << n << ""\\n"";);
    m_emons.pop(n);
    SASSERT(elists_are_consistent(false));
}

rational core::product_value(const monic& m) const {
    rational r(1);
    for (auto j : m.vars()) {
        r *= m_lar_solver.get_column_value(j).x;
    }
    return r;
}
    
// return true iff the monic value is equal to the product of the values of the factors
bool core::check_monic(const monic& m) const {    
    SASSERT((!m_lar_solver.column_is_int(m.var())) || m_lar_solver.get_column_value(m.var()).is_int());
    bool ret = product_value(m) == m_lar_solver.get_column_value(m.var()).x; 
    CTRACE(""nla_solver_check_monic"", !ret, print_monic(m, tout) << '\\n';);
    return ret;
}
    

template <typename T>
std::ostream& core::print_product(const T & m, std::ostream& out) const {
    bool first = true;
    for (lpvar v : m) {
        if (!first) out << ""*""; else first = false;
        if (lp_settings().print_external_var_name())
            out << ""("" << m_lar_solver.get_variable_name(v) << ""="" << val(v) << "")"";
        else
            out << ""(j"" << v << "" = "" << val(v) << "")"";
            
    }
    return out;
}
template <typename T>
std::string core::product_indices_str(const T & m) const {
    std::stringstream out;
    bool first = true;
    for (lpvar v : m) {
        if (!first)
            out << ""*"";
        else
            first = false;
        out << ""j"" << v;;
    }
    return out.str();
}

std::ostream & core::print_factor(const factor& f, std::ostream& out) const {
    if (f.sign())
        out << ""- "";
    if (f.is_var()) {
        out << ""VAR,  "" << pp(f.var());
    } else {
        out << ""MON, v"" << m_emons[f.var()] << "" = "";
        print_product(m_emons[f.var()].rvars(), out);
    }
    out << ""\\n"";
    return out;
}

std::ostream & core::print_factor_with_vars(const factor& f, std::ostream& out) const {
    if (f.is_var()) {
        out << pp(f.var());
    } 
    else {
        out << "" MON = "" << pp_mon_with_vars(*this, m_emons[f.var()]);
    }
    return out;
}

std::ostream& core::print_monic(const monic& m, std::ostream& out) const {
    if (lp_settings().print_external_var_name())
        out << ""(["" << m.var() << ""] = "" << m_lar_solver.get_variable_name(m.var()) << "" = "" << val(m.var()) << "" = "";
    else 
        out << ""(j"" << m.var() << "" = "" << val(m.var()) << "" = "";
    print_product(m.vars(), out) << "")\\n"";
    return out;
}


std::ostream& core::print_bfc(const factorization& m, std::ostream& out) const {
    SASSERT(m.size() == 2);
    out << ""( x = "" << pp(m[0]) << ""* y = "" << pp(m[1]) << "")"";
    return out;
}

std::ostream& core::print_monic_with_vars(lpvar v, std::ostream& out) const {
    return print_monic_with_vars(m_emons[v], out);
}
template <typename T>
std::ostream& core::print_product_with_vars(const T& m, std::ostream& out) const {
    print_product(m, out) << ""\\n"";
    for (unsigned k = 0; k < m.size(); k++) {
        print_var(m[k], out);
    }
    return out;
}

std::ostream& core::print_monic_with_vars(const monic& m, std::ostream& out) const {
    out << ""["" << pp(m.var()) << ""]\\n"";
    out << ""vars:""; print_product_with_vars(m.vars(), out) << ""\\n"";
    if (m.vars() == m.rvars())
        out << ""same rvars, and m.rsign = "" << m.rsign() << "" of course\\n"";
    else {
        out << ""rvars:""; print_product_with_vars(m.rvars(), out) << ""\\n"";
        out << ""rsign:"" << m.rsign() << ""\\n"";
    }
    return out;
}

std::ostream& core::print_explanation(const lp::explanation& exp, std::ostream& out) const {
    out << ""expl: "";
    unsigned i = 0;
    for (auto p : exp) {
        out << ""("" << p.ci() << "")"";
        m_lar_solver.constraints().display(out, [this](lpvar j) { return var_str(j);}, p.ci());
        if (++i < exp.size())
            out << ""      "";
    }
    return out;
}

bool core::explain_upper_bound(const lp::lar_term& t, const rational& rs, lp::explanation& e) const {
    rational b(0); // the bound
    for (const auto& p : t) {
        rational pb;
        if (explain_coeff_upper_bound(p, pb, e)) {
            b += pb;
        } else {
            e.clear();
            return false;
        }
    }
    if (b > rs ) {
        e.clear();
        return false;
    }
    return true;
}
bool core::explain_lower_bound(const lp::lar_term& t, const rational& rs, lp::explanation& e) const {
    rational b(0); // the bound
    for (const auto& p : t) {
        rational pb;
        if (explain_coeff_lower_bound(p, pb, e)) {
            b += pb;
        } else {
            e.clear();
            return false;
        }
    }
    if (b < rs ) {
        e.clear();
        return false;
    }
    return true;
}

bool core::explain_coeff_lower_bound(const lp::lar_term::ival& p, rational& bound, lp::explanation& e) const {
    const rational& a = p.coeff();
    SASSERT(!a.is_zero());
    unsigned c; // the index for the lower or the upper bound
    if (a.is_pos()) {
        unsigned c = m_lar_solver.get_column_lower_bound_witness(p.column());
        if (c + 1 == 0)
            return false;
        bound = a * m_lar_solver.get_lower_bound(p.column()).x;
        e.push_back(c);
        return true;
    }
    // a.is_neg()
    c = m_lar_solver.get_column_upper_bound_witness(p.column());
    if (c + 1 == 0)
        return false;
    bound = a * m_lar_solver.get_upper_bound(p.column()).x;
    e.push_back(c);
    return true;
}

bool core::explain_coeff_upper_bound(const lp::lar_term::ival& p, rational& bound, lp::explanation& e) const {
    const rational& a = p.coeff();
    lpvar j = p.column();
    SASSERT(!a.is_zero());
    unsigned c; // the index for the lower or the upper bound
    if (a.is_neg()) {
        unsigned c = m_lar_solver.get_column_lower_bound_witness(j);
        if (c + 1 == 0)
            return false;
        bound = a * m_lar_solver.get_lower_bound(j).x;
        e.push_back(c);
        return true;
    }
    // a.is_pos()
    c = m_lar_solver.get_column_upper_bound_witness(j);
    if (c + 1 == 0)
        return false;
    bound = a * m_lar_solver.get_upper_bound(j).x;
    e.push_back(c);
    return true;
}
    
// return true iff the negation of the ineq can be derived from the constraints
bool core::explain_ineq(new_lemma& lemma, const lp::lar_term& t, llc cmp, const rational& rs) {
    // check that we have something like 0 < 0, which is always false and can be safely
    // removed from the lemma
        
    if (t.is_empty() && rs.is_zero() &&
        (cmp == llc::LT || cmp == llc::GT || cmp == llc::NE)) return true;
    lp::explanation exp;
    bool r;
    switch (negate(cmp)) {
    case llc::LE:
        r = explain_upper_bound(t, rs, exp);
        break;
    case llc::LT:
        r = explain_upper_bound(t, rs - rational(1), exp);
        break;
    case llc::GE: 
        r = explain_lower_bound(t, rs, exp);
        break;
    case llc::GT:
        r = explain_lower_bound(t, rs + rational(1), exp);
        break;

    case llc::EQ:
        r = (explain_lower_bound(t, rs, exp) && explain_upper_bound(t, rs, exp)) ||
            (rs.is_zero() && explain_by_equiv(t, exp));
        break;
    case llc::NE:
        // TBD - NB: does this work for Reals?
        r = explain_lower_bound(t, rs + rational(1), exp) || explain_upper_bound(t, rs - rational(1), exp);           
        break;
    default:
        UNREACHABLE();
        return false;
    }
    if (r) {
        lemma &= exp;
        return true;
    }
        
    return false;
}

/**
 * \\brief
 if t is an octagon term -+x -+ y try to explain why the term always is
 equal zero
*/
bool core::explain_by_equiv(const lp::lar_term& t, lp::explanation& e) const {
    lpvar i,j;
    bool sign;
    if (!is_octagon_term(t, sign, i, j))
        return false;
    if (m_evars.find(signed_var(i, false)) != m_evars.find(signed_var(j, sign)))
        return false;
            
    m_evars.explain(signed_var(i, false), signed_var(j, sign), e);
    TRACE(""nla_solver"", tout << ""explained :""; m_lar_solver.print_term_as_indices(t, tout););
    return true;            
}

void core::mk_ineq_no_expl_check(new_lemma& lemma, lp::lar_term& t, llc cmp, const rational& rs) {
    TRACE(""nla_solver_details"", m_lar_solver.print_term_as_indices(t, tout << ""t = ""););
    lemma |= ineq(cmp, t, rs);
    CTRACE(""nla_solver"", ineq_holds(ineq(cmp, t, rs)), print_ineq(ineq(cmp, t, rs), tout) << ""\\n"";);
    SASSERT(!ineq_holds(ineq(cmp, t, rs)));
}

llc apply_minus(llc cmp) {
    switch(cmp) {
    case llc::LE: return llc::GE;
    case llc::LT: return llc::GT;
    case llc::GE: return llc::LE;
    case llc::GT: return llc::LT;
    default: break;
    }
    return cmp;
}   
    
// the monics should be equal by modulo sign but this is not so in the model
void core::fill_explanation_and_lemma_sign(new_lemma& lemma, const monic& a, const monic & b, rational const& sign) {
    SASSERT(sign == 1 || sign == -1);
    lemma &= a;
    lemma &= b;
    TRACE(""nla_solver"", tout << ""used constraints: "" << lemma;);
    SASSERT(lemma.num_ineqs() == 0);
    lemma |= ineq(term(rational(1), a.var(), -sign, b.var()), llc::EQ, 0);
}

// Replaces each variable index by the root in the tree and flips the sign if the var comes with a minus.
// Also sorts the result.
// 
svector<lpvar> core::reduce_monic_to_rooted(const svector<lpvar> & vars, rational & sign) const {
    svector<lpvar> ret;
    bool s = false;
    for (lpvar v : vars) {
        auto root = m_evars.find(v);
        s ^= root.sign();
        TRACE(""nla_solver_eq"",
              tout << pp(v) << "" mapped to "" << pp(root.var()) << ""\\n"";);
        ret.push_back(root.var());
    }
    sign = rational(s? -1: 1);
    std::sort(ret.begin(), ret.end());
    return ret;
}


// Replaces definition m_v = v1* .. * vn by
// m_v = coeff * w1 * ... * wn, where w1, .., wn are canonical
// representatives, which are the roots of the equivalence tree, under current equations.
// 
monic_coeff core::canonize_monic(monic const& m) const {
    rational sign = rational(1);
    svector<lpvar> vars = reduce_monic_to_rooted(m.vars(), sign);
    return monic_coeff(vars, sign);
}

int core::vars_sign(const svector<lpvar>& v) {
    int sign = 1;
    for (lpvar j : v) {
        sign *= nla::rat_sign(val(j));
        if (sign == 0) 
            return 0;
    }
    return sign;
}
   
bool core::has_upper_bound(lpvar j) const {
    return m_lar_solver.column_has_upper_bound(j);
} 

bool core::has_lower_bound(lpvar j) const {
    return m_lar_solver.column_has_lower_bound(j);
} 
const rational& core::get_upper_bound(unsigned j) const {
    return m_lar_solver.get_upper_bound(j).x;
}

const rational& core::get_lower_bound(unsigned j) const {
    return m_lar_solver.get_lower_bound(j).x;
}    
    
bool core::zero_is_an_inner_point_of_bounds(lpvar j) const {
    if (has_upper_bound(j) && get_upper_bound(j) <= rational(0))            
        return false;
    if (has_lower_bound(j) && get_lower_bound(j) >= rational(0))            
        return false;
    return true;
}
    
int core::rat_sign(const monic& m) const {
    int sign = 1;
    for (lpvar j : m.vars()) {
        auto v = val(j);
        if (v.is_neg()) {
            sign = - sign;
            continue;
        }
        if (v.is_pos()) {
            continue;
        }
        sign = 0;
        break;
    }
    return sign;
}

// Returns true if the monic sign is incorrect
bool core::sign_contradiction(const monic& m) const {
    return  nla::rat_sign(var_val(m)) != rat_sign(m);
}

/*
  unsigned_vector eq_vars(lpvar j) const {
  TRACE(""nla_solver_eq"", tout << ""j = "" << pp(j) << ""eqs = "";
  for(auto jj : m_evars.eq_vars(j)) tout << pp(jj) << "" "";
  });
  return m_evars.eq_vars(j);
  }
*/

bool core::var_is_fixed_to_zero(lpvar j) const {
    return 
        m_lar_solver.column_is_fixed(j) &&
        m_lar_solver.get_lower_bound(j) == lp::zero_of_type<lp::impq>();
}
bool core::var_is_fixed_to_val(lpvar j, const rational& v) const {
    return 
        m_lar_solver.column_is_fixed(j) &&
        m_lar_solver.get_lower_bound(j) == lp::impq(v);
}

bool core::var_is_fixed(lpvar j) const {
    return m_lar_solver.column_is_fixed(j);
}

bool core::var_is_free(lpvar j) const {
    return m_lar_solver.column_is_free(j);
}
    
std::ostream & core::print_ineq(const ineq & in, std::ostream & out) const {
    m_lar_solver.print_term_as_indices(in.term(), out);
    out << "" "" << lconstraint_kind_string(in.cmp()) << "" "" << in.rs();
    return out;
}

std::ostream & core::print_var(lpvar j, std::ostream & out) const {
    if (m_emons.is_monic_var(j)) {
        print_monic(m_emons[j], out);
    }
        
    m_lar_solver.print_column_info(j, out);
    signed_var jr = m_evars.find(j);
    out << ""root="";
    if (jr.sign()) {
        out << ""-"";
    }
        
    out << m_lar_solver.get_variable_name(jr.var()) << ""\\n"";
    return out;
}

std::ostream & core::print_monics(std::ostream & out) const {
    for (auto &m : m_emons) {
        print_monic_with_vars(m, out);
    }
    return out;
}    

std::ostream & core::print_ineqs(const lemma& l, std::ostream & out) const {
    std::unordered_set<lpvar> vars;
    out << ""ineqs: "";
    if (l.ineqs().size() == 0) {
        out << ""conflict\\n"";
    } else {
        for (unsigned i = 0; i < l.ineqs().size(); i++) {
            auto & in = l.ineqs()[i]; 
            print_ineq(in, out);
            if (i + 1 < l.ineqs().size()) out << "" or "";
            for (const auto & p: in.term())
                vars.insert(p.column());
        }
        out << std::endl;
        for (lpvar j : vars) {
            print_var(j, out);
        }
        out << ""\\n"";
    }
    return out;
}
    
std::ostream & core::print_factorization(const factorization& f, std::ostream& out) const {
    if (f.is_mon()){
        out << ""is_mon "" << pp_mon(*this, f.mon());
    } 
    else {
        for (unsigned k = 0; k < f.size(); k++ ) {
            out << ""("" << pp(f[k]) << "")"";
            if (k < f.size() - 1)
                out << ""*"";
        }
    }
    return out;
}
    
bool core::find_canonical_monic_of_vars(const svector<lpvar>& vars, lpvar & i) const {
    monic const* sv = m_emons.find_canonical(vars);
    return sv && (i = sv->var(), true);
}

bool core::is_canonical_monic(lpvar j) const {
    return m_emons.is_canonical_monic(j);
}


void core::trace_print_monic_and_factorization(const monic& rm, const factorization& f, std::ostream& out) const {
    out << ""rooted vars: "";
    print_product(rm.rvars(), out) << ""\\n"";
    out << ""mon:   "" << pp_mon(*this, rm.var()) << ""\\n"";
    out << ""value: "" << var_val(rm) << ""\\n"";
    print_factorization(f, out << ""fact: "") << ""\\n"";
}


bool core::var_has_positive_lower_bound(lpvar j) const {
    return m_lar_solver.column_has_lower_bound(j) && m_lar_solver.get_lower_bound(j) > lp::zero_of_type<lp::impq>();
}

bool core::var_has_negative_upper_bound(lpvar j) const {
    return m_lar_solver.column_has_upper_bound(j) && m_lar_solver.get_upper_bound(j) < lp::zero_of_type<lp::impq>();
}
    
bool core::var_is_separated_from_zero(lpvar j) const {
    return
        var_has_negative_upper_bound(j) ||
        var_has_positive_lower_bound(j);
}
    

bool core::vars_are_equiv(lpvar a, lpvar b) const {
    SASSERT(abs(val(a)) == abs(val(b)));
    return m_evars.vars_are_equiv(a, b);
}
    
bool core::has_zero_factor(const factorization& factorization) const {
    for (factor f : factorization) {
        if (val(f).is_zero())
            return true;
    }
    return false;
}


template <typename T>
bool core::mon_has_zero(const T& product) const {
    for (lpvar j: product) {
        if (val(j).is_zero())
            return true;
    }
    return false;
}

template bool core::mon_has_zero<unsigned_vector>(const unsigned_vector& product) const;


lp::lp_settings& core::lp_settings() {
    return m_lar_solver.settings();
}
const lp::lp_settings& core::lp_settings() const {
    return m_lar_solver.settings();
}
    
unsigned core::random() { return lp_settings().random_next(); }
    

// we look for octagon constraints here, with a left part  +-x +- y 
void core::collect_equivs() {
    const lp::lar_solver& s = m_lar_solver;

    for (unsigned i = 0; i < s.terms().size(); i++) {
        if (!s.term_is_used_as_row(i))
            continue;
        lpvar j = s.external_to_local(lp::tv::mask_term(i));
        if (var_is_fixed_to_zero(j)) {
            TRACE(""nla_solver_mons"", s.print_term_as_indices(*s.terms()[i], tout << ""term = "") << ""\\n"";);
            add_equivalence_maybe(s.terms()[i], s.get_column_upper_bound_witness(j), s.get_column_lower_bound_witness(j));
        }
    }
    m_emons.ensure_canonized();
}


// returns true iff the term is in a form +-x-+y.
// the sign is true iff the term is x+y, -x-y.
bool core::is_octagon_term(const lp::lar_term& t, bool & sign, lpvar& i, lpvar &j) const {
    if (t.size() != 2)
        return false;
    bool seen_minus = false;
    bool seen_plus = false;
    i = null_lpvar;
    for(const auto & p : t) {
        const auto & c = p.coeff();
        if (c == 1) {
            seen_plus = true;
        } else if (c == - 1) {
            seen_minus = true;
        } else {
            return false;
        }
        if (i == null_lpvar)
            i = p.column();
        else
            j = p.column();
    }
    SASSERT(j != null_lpvar);
    sign = (seen_minus && seen_plus)? false : true;
    return true;
}
    
void core::add_equivalence_maybe(const lp::lar_term *t, lpci c0, lpci c1) {
    bool sign;
    lpvar i, j;
    if (!is_octagon_term(*t, sign, i, j))
        return;
    if (sign)
        m_evars.merge_minus(i, j, eq_justification({c0, c1}));
    else 
        m_evars.merge_plus(i, j, eq_justification({c0, c1}));
}

// x is equivalent to y if x = +- y
void core::init_vars_equivalence() {
    collect_equivs();
    //    SASSERT(tables_are_ok());
}

bool core::vars_table_is_ok() const {
    // return m_var_eqs.is_ok();
    return true;
}

bool core::rm_table_is_ok() const {
    // return m_emons.is_ok();
    return true;
}
    
bool core::tables_are_ok() const {
    return vars_table_is_ok() && rm_table_is_ok();
}
    
bool core::var_is_a_root(lpvar j) const { return m_evars.is_root(j); }

template <typename T>
bool core::vars_are_roots(const T& v) const {
    for (lpvar j: v) {
        if (!var_is_a_root(j))
            return false;
    }
    return true;
}



template <typename T>
void core::trace_print_rms(const T& p, std::ostream& out) {
    out << ""p = {\\n"";
    for (auto j : p) {
        out << ""j = "" << j << "", rm = "" << m_emons[j] << ""\\n"";
    }
    out << ""}"";
}

void core::print_monic_stats(const monic& m, std::ostream& out) {
    if (m.size() == 2) return;
    monic_coeff mc = canonize_monic(m);
    for(unsigned i = 0; i < mc.vars().size(); i++){
        if (abs(val(mc.vars()[i])) == rational(1)) {
            auto vv = mc.vars();
            vv.erase(vv.begin()+i);
            monic const* sv = m_emons.find_canonical(vv);
            if (!sv) {
                out << ""nf length"" << vv.size() << ""\\n""; ;
            }
        }
    }
}
    
void core::print_stats(std::ostream& out) {
}
        

void core::clear() {
    m_lemma_vec->clear();
}
    
void core::init_search() {
    TRACE(""nla_solver_mons"", tout << ""init\\n"";);
    SASSERT(m_emons.invariant());
    clear();
    init_vars_equivalence();
    SASSERT(m_emons.invariant());
    SASSERT(elists_are_consistent(false));
}

void core::insert_to_refine(lpvar j) {
    TRACE(""lar_solver"", tout << ""j="" << j << '\\n';);
    m_to_refine.insert(j);
}

void core::erase_from_to_refine(lpvar j) {
    TRACE(""lar_solver"", tout << ""j="" << j << '\\n';);
    m_to_refine.erase(j);
}


void core::init_to_refine() {
    TRACE(""nla_solver_details"", tout << ""emons:"" << pp_emons(*this, m_emons););
    m_to_refine.clear();
    m_to_refine.resize(m_lar_solver.number_of_vars());
    unsigned r = random(), sz = m_emons.number_of_monics();
    for (unsigned k = 0; k < sz; k++) {
        auto const & m = *(m_emons.begin() + (k + r)% sz);
        if (!check_monic(m)) 
            insert_to_refine(m.var());
    }
    
    TRACE(""nla_solver"", 
          tout << m_to_refine.size() << "" mons to refine:\\n"";
          for (lpvar v : m_to_refine) tout << pp_mon(*this, m_emons[v]) << "":error = "" <<
                                          (val(v) - mul_val(m_emons[v])).get_double() << ""\\n"";);
}
        
std::unordered_set<lpvar> core::collect_vars(const lemma& l) const {
    std::unordered_set<lpvar> vars;
    auto insert_j = [&](lpvar j) { 
        vars.insert(j);
        if (m_emons.is_monic_var(j)) {
            for (lpvar k : m_emons[j].vars())
                vars.insert(k);
        }
    };
    
    for (const auto& i : l.ineqs()) {
        for (const auto& p : i.term()) {                
            insert_j(p.column());
        }
    }
    for (const auto& p : l.expl()) {
        const auto& c = m_lar_solver.constraints()[p.ci()];
        for (const auto& r : c.coeffs()) {
            insert_j(r.second);
        }
    }
    return vars;
}

// divides bc by c, so bc = b*c
bool core::divide(const monic& bc, const factor& c, factor & b) const {
    svector<lpvar> c_rvars = sorted_rvars(c);
    TRACE(""nla_solver_div"", tout << ""c_rvars = ""; print_product(c_rvars, tout); tout << ""\\nbc_rvars = ""; print_product(bc.rvars(), tout););
    if (!lp::is_proper_factor(c_rvars, bc.rvars()))
        return false;
            
    auto b_rvars = lp::vector_div(bc.rvars(), c_rvars);
    TRACE(""nla_solver_div"", tout << ""b_rvars = ""; print_product(b_rvars, tout););
    SASSERT(b_rvars.size() > 0);
    if (b_rvars.size() == 1) {
        b = factor(b_rvars[0], factor_type::VAR);
    } else {
        monic const* sv = m_emons.find_canonical(b_rvars);
        if (sv == nullptr) {
            TRACE(""nla_solver_div"", tout << ""not in rooted"";);
            return false;
        }
        b = factor(sv->var(), factor_type::MON);
    }
    SASSERT(!b.sign());
    // We have bc = canonize_sign(bc)*bc.rvars() = canonize_sign(b)*b.rvars()*canonize_sign(c)*c.rvars().
    // Dividing by bc.rvars() we get canonize_sign(bc) = canonize_sign(b)*canonize_sign(c)
    // Currently, canonize_sign(b) is 1, we might need to adjust it
    b.sign() = canonize_sign(b) ^ canonize_sign(c) ^ canonize_sign(bc); 
    TRACE(""nla_solver"", tout << ""success div:"" << pp(b) << ""\\n"";);
    return true;
}


void core::negate_factor_equality(new_lemma& lemma, const factor& c,
                                  const factor& d) {
    if (c == d)
        return;
    lpvar i = var(c);
    lpvar j = var(d);
    auto iv = val(i), jv = val(j);
    SASSERT(abs(iv) == abs(jv));
    lemma |= ineq(term(i, rational(iv == jv ? -1 : 1), j), llc::NE, 0);    
}
    
void core::negate_factor_relation(new_lemma& lemma, const rational& a_sign, const factor& a, const rational& b_sign, const factor& b) {
    rational a_fs = sign_to_rat(canonize_sign(a));
    rational b_fs = sign_to_rat(canonize_sign(b));
    llc cmp = a_sign*val(a) < b_sign*val(b)? llc::GE : llc::LE;
    lemma |= ineq(term(a_fs*a_sign, var(a), - b_fs*b_sign, var(b)), cmp, 0);
}

std::ostream& core::print_lemma(const lemma& l, std::ostream& out) const {
    static int n = 0;
    out << ""lemma:"" << ++n << "" "";    
    print_ineqs(l, out);
    print_explanation(l.expl(), out);        
    for (lpvar j : collect_vars(l)) {
        print_var(j, out);
    }
    return out;
}
    

void core::trace_print_ol(const monic& ac,
                          const factor& a,
                          const factor& c,
                          const monic& bc,
                          const factor& b,
                          std::ostream& out) {
    out << ""ac = "" << pp_mon(*this, ac) << ""\\n"";
    out << ""bc = "" << pp_mon(*this, bc) << ""\\n"";
    out << ""a = "";
    print_factor_with_vars(a, out);
    out << "", \\nb = "";
    print_factor_with_vars(b, out);
    out << ""\\nc = "";
    print_factor_with_vars(c, out);
}
    
void core::maybe_add_a_factor(lpvar i,
                              const factor& c,
                              std::unordered_set<lpvar>& found_vars,
                              std::unordered_set<unsigned>& found_rm,
                              vector<factor> & r) const {
    SASSERT(abs(val(i)) == abs(val(c)));
    if (!m_emons.is_monic_var(i)) {
        i = m_evars.find(i).var();
        if (try_insert(i, found_vars)) {
            r.push_back(factor(i, factor_type::VAR));
        }
    } else {
        if (try_insert(i, found_rm)) {
            r.push_back(factor(i, factor_type::MON));
            TRACE(""nla_solver"", tout << ""inserting factor = ""; print_factor_with_vars(factor(i, factor_type::MON), tout); );
        }
    }
}
    

// Returns rooted monics by arity
std::unordered_map<unsigned, unsigned_vector> core::get_rm_by_arity() {
    std::unordered_map<unsigned, unsigned_vector> m;
    for (auto const& mon : m_emons) {
        unsigned arity = mon.vars().size();
        auto it = m.find(arity);
        if (it == m.end()) {
            it = m.insert(it, std::make_pair(arity, unsigned_vector()));
        }
        it->second.push_back(mon.var());
    }
    return m;
}

bool core::rm_check(const monic& rm) const {
    return check_monic(m_emons[rm.var()]);
}

    
bool core::find_bfc_to_refine_on_monic(const monic& m, factorization & bf) {
    for (auto f : factorization_factory_imp(m, *this)) {
        if (f.size() == 2) {
            auto a = f[0];
            auto b = f[1];
            if (var_val(m) != val(a) * val(b)) {
                bf = f;
                TRACE(""nla_solver"", tout << ""found bf"";
                      tout << "":m:"" << pp_mon_with_vars(*this, m) << ""\\n"";
                      tout << ""bf:""; print_bfc(bf, tout););
                      
                return true;
            }
        }
    }
    return false;
}

// finds a monic to refine with its binary factorization
bool core::find_bfc_to_refine(const monic* & m, factorization & bf){
    m = nullptr;
    unsigned r = random(), sz = m_to_refine.size();
    for (unsigned k = 0; k < sz; k++) {
        lpvar i = m_to_refine[(k + r) % sz];
        m = &m_emons[i];
        SASSERT (!check_monic(*m));
        if (has_real(m))
            continue;
        if (m->size() == 2) {
            bf.set_mon(m);
            bf.push_back(factor(m->vars()[0], factor_type::VAR));
            bf.push_back(factor(m->vars()[1], factor_type::VAR));
            return true;
        }
                
        if (find_bfc_to_refine_on_monic(*m, bf)) {
            TRACE(""nla_solver"",
                  tout << ""bf = ""; print_factorization(bf, tout);
                  tout << ""\\nval(*m) = "" << var_val(*m) << "", should be = (val(bf[0])="" << val(bf[0]) << "")*(val(bf[1]) = "" << val(bf[1]) << "") = "" << val(bf[0])*val(bf[1]) << ""\\n"";);
            return true;
        } 
    }
    return false;
}

rational core::val(const factorization& f) const {
    rational r(1);
    for (const factor &p : f) {
        r *= val(p);
    }
    return r;
}

new_lemma::new_lemma(core& c, char const* name):name(name), c(c) {
    c.m_lemma_vec->push_back(lemma());
}

new_lemma& new_lemma::operator|=(ineq const& ineq) {
    if (!c.explain_ineq(*this, ineq.term(), ineq.cmp(), ineq.rs())) {
        CTRACE(""nla_solver"", c.ineq_holds(ineq), c.print_ineq(ineq, tout) << ""\\n"";);
        SASSERT(!c.ineq_holds(ineq));
        current().push_back(ineq);
    }
    return *this;
}
    

new_lemma::~new_lemma() {
    static int i = 0;
    (void)i;
    (void)name;
    // code for checking lemma can be added here
    TRACE(""nla_solver"", tout << name << "" "" << (++i) << ""\\n"" << *this; );
}

lemma& new_lemma::current() const {
    return c.m_lemma_vec->back();
}

new_lemma& new_lemma::operator&=(lp::explanation const& e) {
    expl().add_expl(e);
    return *this;
}

new_lemma& new_lemma::operator&=(const monic& m) {
    for (lpvar j : m.vars())
        *this &= j;
    return *this;
}

new_lemma& new_lemma::operator&=(const factor& f) {
    if (f.type() == factor_type::VAR) 
        *this &= f.var();
    else 
        *this &= c.m_emons[f.var()];
    return *this;
}

new_lemma& new_lemma::operator&=(const factorization& f) {
    if (f.is_mon())
        return *this;
    for (const auto& fc : f) {
        *this &= fc;
    }
    return *this;
}

new_lemma& new_lemma::operator&=(lpvar j) {
    c.m_evars.explain(j, expl());
    return *this;
}

new_lemma& new_lemma::explain_fixed(lpvar j) {
    SASSERT(c.var_is_fixed(j));
    explain_existing_lower_bound(j);
    explain_existing_upper_bound(j);
    return *this;
}

new_lemma& new_lemma::explain_equiv(lpvar a, lpvar b) {
    SASSERT(abs(c.val(a)) == abs(c.val(b)));
    if (c.vars_are_equiv(a, b)) {
        *this &= a;
        *this &= b;
    } else {
        explain_fixed(a);
        explain_fixed(b);
    }
    return *this;
}

new_lemma& new_lemma::explain_var_separated_from_zero(lpvar j) {
    SASSERT(c.var_is_separated_from_zero(j));
    if (c.m_lar_solver.column_has_upper_bound(j) && 
        (c.m_lar_solver.get_upper_bound(j)< lp::zero_of_type<lp::impq>())) 
        explain_existing_upper_bound(j);
    else 
        explain_existing_lower_bound(j);
    return *this;
}

new_lemma& new_lemma::explain_existing_lower_bound(lpvar j) {
    SASSERT(c.has_lower_bound(j));
    lp::explanation ex;
    ex.push_back(c.m_lar_solver.get_column_lower_bound_witness(j));
    *this &= ex;
    TRACE(""nla_solver"", tout << j << "": "" << *this << ""\\n"";);
    return *this;
}

new_lemma& new_lemma::explain_existing_upper_bound(lpvar j) {
    SASSERT(c.has_upper_bound(j));
    lp::explanation ex;
    ex.push_back(c.m_lar_solver.get_column_upper_bound_witness(j));
    *this &= ex;
    return *this;
}
    
std::ostream& new_lemma::display(std::ostream & out) const {
    auto const& lemma = current();

    for (auto p : lemma.expl()) {
        out << ""("" << p.ci() << "") "";
        c.m_lar_solver.constraints().display(out, [this](lpvar j) { return c.var_str(j);}, p.ci());
    }
    out << "" ==> "";
    if (lemma.ineqs().empty()) {
        out << ""false"";
    }
    else {
        bool first = true;
        for (auto & in : lemma.ineqs()) {
            if (first) first = false; else out << "" or "";
            c.print_ineq(in, out);
        }
    }
    out << ""\\n"";
    for (lpvar j : c.collect_vars(lemma)) {
        c.print_var(j, out);
    }
    return out;
}
    
void core::negate_relation(new_lemma& lemma, unsigned j, const rational& a) {
    SASSERT(val(j) != a);
    lemma |= ineq(j, val(j) < a ? llc::GE : llc::LE, a);   
}

bool core::conflict_found() const {
    for (const auto & l : * m_lemma_vec) {
        if (l.is_conflict())
            return true;
    }
    return false;
}

bool core::done() const {
    return m_lemma_vec->size() >= 10 || 
        conflict_found() || 
        lp_settings().get_cancel_flag();
}

bool core::elist_is_consistent(const std::unordered_set<lpvar> & list) const {
    bool first = true;
    bool p;
    for (lpvar j : list) {
        if (first) {
            p = check_monic(m_emons[j]);
            first = false;
        } else 
            if (check_monic(m_emons[j]) != p)
                return false;
    }
    return true;
}

bool core::elists_are_consistent(bool check_in_model) const {
    std::unordered_map<unsigned_vector, std::unordered_set<lpvar>, hash_svector> lists;
    if (!m_emons.elists_are_consistent(lists))
        return false;

    if (!check_in_model)
        return true;
    for (const auto & p : lists) {
        if (! elist_is_consistent(p.second))
            return false;
    }
    return true;
}

bool core::var_breaks_correct_monic_as_factor(lpvar j, const monic& m) const {
    if (!val(var(m)).is_zero())
        return true;
    
    if (!val(j).is_zero()) // j was not zero: the new value does not matter - m must have another zero factor
        return false;
    // do we have another zero in m?       
    for (lpvar k : m) {
        if (k != j && val(k).is_zero()) {
            return false; // not breaking
        }
    }
    // j was the only zero in m
    return true;
}

bool core::var_breaks_correct_monic(lpvar j) const {
    if (emons().is_monic_var(j) && !m_to_refine.contains(j)) {
        TRACE(""nla_solver"", tout << ""j = "" << j << "", m  = ""; print_monic(emons()[j], tout) << ""\\n"";);
        return true; // changing the value of a correct monic
    }
    
    for (const monic & m : emons().get_use_list(j)) {
        if (m_to_refine.contains(m.var()))
            continue;
        if (var_breaks_correct_monic_as_factor(j, m))
            return true;
    }            

    return false;
}

void core::update_to_refine_of_var(lpvar j) {
    for (const monic & m : emons().get_use_list(j)) {
        if (var_val(m) == mul_val(m)) 
            erase_from_to_refine(var(m));
        else
            insert_to_refine(var(m));
    }
    if (is_monic_var(j)) {
        const monic& m = emons()[j];
        if (var_val(m) == mul_val(m))
            erase_from_to_refine(j);
        else
            insert_to_refine(j);        
    }
}

bool core::var_is_big(lpvar j) const {
    return !var_is_int(j) && val(j).is_big();
}

bool core::has_big_num(const monic& m) const {
    if (var_is_big(var(m)))
        return true;
    for (lpvar j : m.vars())
        if (var_is_big(j))
            return true;
    return false;
}

bool core::has_real(const factorization& f) const {
    for (const factor& fc: f) {
        lpvar j = var(fc);
        if (!var_is_int(j))
            return true;
    }
    return false;
}

bool core::has_real(const monic& m) const {
    for (lpvar j : m.vars())
        if (!var_is_int(j))
            return true;
    return false;
}

// returns true if the patching is blocking
bool core::is_patch_blocked(lpvar u, const lp::impq& ival) const {
    TRACE(""nla_solver"", tout << ""u = "" << u << '\\n';);
    if (m_cautious_patching &&
        (!m_lar_solver.inside_bounds(u, ival) || (var_is_int(u) && ival.is_int() == false))) {
        TRACE(""nla_solver"", tout << ""u = "" << u << "" blocked, for feas or integr\\n"";);
        return true; // block
    }

    if (u == m_patched_var) {
        TRACE(""nla_solver"", tout << ""u == m_patched_var, no block\\n"";);
        
        return false; // do not block
    }
    // we can change only one variable in variables of m_patched_var
    if (m_patched_monic->contains_var(u) || u == var(*m_patched_monic)) {
        TRACE(""nla_solver"", tout << ""u = "" << u << "" blocked as contained\\n"";);
        return true; // block
    }
    
    if (var_breaks_correct_monic(u)) {
        TRACE(""nla_solver"", tout << ""u = "" << u << "" blocked as used in a correct monomial\\n"";);
        return true;
    }
    
    TRACE(""nla_solver"", tout << ""u = "" << u << "", m_patched_m  = ""; print_monic(*m_patched_monic, tout) <<
          "", not blocked\\n"";);
    
    return false;
}

// it tries to patch m_patched_var
bool core::try_to_patch(const rational& v) {
    auto is_blocked = [this](lpvar u, const lp::impq& iv)  { return is_patch_blocked(u, iv); };
    auto change_report = [this](lpvar u) { update_to_refine_of_var(u); };
    return m_lar_solver.try_to_patch(m_patched_var, v, is_blocked, change_report);
}

bool in_power(const svector<lpvar>& vs, unsigned l) {
    unsigned k = vs[l];
    return (l != 0 && vs[l - 1] == k) || (l + 1 < vs.size() && k == vs[l + 1]);
}

bool core::to_refine_is_correct() const {
    for (unsigned j = 0; j < m_lar_solver.number_of_vars(); j++) {
        if (!emons().is_monic_var(j)) continue;
        bool valid = check_monic(emons()[j]);
        if (valid == m_to_refine.contains(j)) {
            TRACE(""nla_solver"", tout << ""inconstency in m_to_refine : "";
                  print_monic(emons()[j], tout) << ""\\n"";
                  if (valid) tout << ""should NOT be in to_refine\\n"";
                  else tout << ""should be in to_refine\\n"";);
            return false;
        }
    }
    return true;
}

void core::patch_monomial(lpvar j) {    
    m_patched_monic =& (emons()[j]);
    m_patched_var = j;
    TRACE(""nla_solver"", tout << ""m = ""; print_monic(*m_patched_monic, tout) << ""\\n"";);
    rational v = mul_val(*m_patched_monic);
    if (val(j) == v) {
        erase_from_to_refine(j);
        return;
    }
    if (!var_breaks_correct_monic(j) && try_to_patch(v)) {
        SASSERT(to_refine_is_correct());        
        return;
    }
  
    // We could not patch j, now we try patching the factor variables.
    TRACE(""nla_solver"", tout << "" trying squares\\n"";);
    // handle perfect squares
    if ((*m_patched_monic).vars().size() == 2 && (*m_patched_monic).vars()[0] == (*m_patched_monic).vars()[1]) {        
        rational root;
        if (v.is_perfect_square(root)) {
            m_patched_var = (*m_patched_monic).vars()[0];
            if (!var_breaks_correct_monic(m_patched_var) && (try_to_patch(root) || try_to_patch(-root))) { 
                TRACE(""nla_solver"", tout << ""patched square\\n"";);
                return;
            }
        }
        TRACE(""nla_solver"", tout << "" cannot patch\\n"";);
        return;
    }

    // We have v != abc, but we need to have v = abc.
    // If we patch b then b should be equal to v/ac = v/(abc/b) = b(v/abc)
    if (!v.is_zero()) {
        rational r = val(j) / v;
        SASSERT((*m_patched_monic).is_sorted());
        TRACE(""nla_solver"", tout << ""r = "" << r << "", v = "" << v << ""\\n"";);
        for (unsigned l = 0; l < (*m_patched_monic).size(); l++) {
            m_patched_var = (*m_patched_monic).vars()[l];
            if (!in_power((*m_patched_monic).vars(), l) &&
                !var_breaks_correct_monic(m_patched_var) &&
                try_to_patch(r * val(m_patched_var))) { // r * val(k) gives the right value of k
                TRACE(""nla_solver"", tout << ""patched  "" << m_patched_var << ""\\n"";);
                SASSERT(mul_val((*m_patched_monic)) == val(j));
                erase_from_to_refine(j);
                break;
            }
        }
    }
}

void core::patch_monomials_on_to_refine() {
    auto to_refine = m_to_refine.index();
    // the rest of the function might change m_to_refine, so have to copy
    unsigned sz = to_refine.size();

    unsigned start = random();
    for (unsigned i = 0; i < sz; i++) {
        patch_monomial(to_refine[(start + i) % sz]);
        if (m_to_refine.size() == 0)
            break;
    }
    TRACE(""nla_solver"", tout << ""sz = "" << sz << "", m_to_refine = "" << m_to_refine.size() <<
          (sz > m_to_refine.size()? "" less"" : ""same"" ) << ""\\n"";);
}

void core::patch_monomials() {
    m_cautious_patching = true;
    patch_monomials_on_to_refine();
    if (m_to_refine.size() == 0 || !m_nla_settings.expensive_patching()) {
        return;
    }
    NOT_IMPLEMENTED_YET();
    m_cautious_patching = false; 
    patch_monomials_on_to_refine();
    m_lar_solver.push();
    save_tableau();
    constrain_nl_in_tableau();
    if (solve_tableau() && integrality_holds()) {
        m_lar_solver.pop(1);
    } else {
        m_lar_solver.pop();
        restore_tableau();
        m_lar_solver.clear_inf_set();
    }
    SASSERT(m_lar_solver.ax_is_correct());
}

void core::constrain_nl_in_tableau() {
    NOT_IMPLEMENTED_YET();
}

bool core::solve_tableau() {
    NOT_IMPLEMENTED_YET();
    return false;
}

void core::restore_tableau() {
    NOT_IMPLEMENTED_YET();
}

void core::save_tableau() {
    NOT_IMPLEMENTED_YET();
}

bool core::integrality_holds() {
    NOT_IMPLEMENTED_YET();
    return false;
}


lbool core::check(vector<lemma>& l_vec) {
    lp_settings().stats().m_nla_calls++;
    TRACE(""nla_solver"", tout << ""calls = "" << lp_settings().stats().m_nla_calls << ""\\n"";);
    m_lar_solver.get_rid_of_inf_eps();
    m_lemma_vec =  &l_vec;
    if (!(m_lar_solver.get_status() == lp::lp_status::OPTIMAL || 
          m_lar_solver.get_status() == lp::lp_status::FEASIBLE)) {
        TRACE(""nla_solver"", tout << ""unknown because of the m_lar_solver.m_status = "" << m_lar_solver.get_status() << ""\\n"";);
        return l_undef;
    }

    init_to_refine();
    patch_monomials();
    set_use_nra_model(false);    
    if (m_to_refine.is_empty()) { return l_true; }   
    init_search();

    lbool ret = l_undef;

    if (l_vec.empty() && !done()) 
        m_monomial_bounds();
    
    if (l_vec.empty() && !done() && need_run_horner()) 
        m_horner.horner_lemmas();

    if (l_vec.empty() && !done() && need_run_grobner()) {
        run_grobner();                
    }

    if (l_vec.empty() && !done()) 
        m_basics.basic_lemma(true);    

    if (l_vec.empty() && !done()) 
        m_basics.basic_lemma(false);
    
    if (l_vec.empty() && !done()) 
        m_order.order_lemma();    

    if (l_vec.empty() && !done()) {
        if (!done())
            m_monotone.monotonicity_lemma();
        if (!done())
            m_tangents.tangent_lemma();
    }

    if (l_vec.empty() && !done() && m_nla_settings.run_nra()) {
        ret = m_nra.check();
        m_stats.m_nra_calls ++;
    }
    
    if (ret == l_undef && !l_vec.empty() && m_reslim.inc()) 
        ret = l_false;

    m_stats.m_nla_lemmas += l_vec.size();
    for (const auto& l : l_vec)
        m_stats.m_nla_explanations += static_cast<unsigned>(l.expl().size());

    
    TRACE(""nla_solver"", tout << ""ret = "" << ret << "", lemmas count = "" << l_vec.size() << ""\\n"";);
    IF_VERBOSE(2, if(ret == l_undef) {verbose_stream() << ""Monomials\\n""; print_monics(verbose_stream());});
    CTRACE(""nla_solver"", ret == l_undef, tout << ""Monomials\\n""; print_monics(tout););
    return ret;
}

bool core::no_lemmas_hold() const {
    for (auto & l : * m_lemma_vec) {
        if (lemma_holds(l)) {
            TRACE(""nla_solver"", print_lemma(l, tout););
            return false;
        }
    }
    return true;
}
    
lbool core::test_check(vector<lemma>& l) {
    m_lar_solver.set_status(lp::lp_status::OPTIMAL);
    return check(l);
}

std::ostream& core::print_terms(std::ostream& out) const {
    for (unsigned i = 0; i< m_lar_solver.terms().size(); i++) {
        unsigned ext = lp::tv::mask_term(i);
        if (!m_lar_solver.var_is_registered(ext)) {
            out << ""term is not registered\\n"";
            continue;
        }
        
        const lp::lar_term & t = *m_lar_solver.terms()[i];
        out << ""term:""; print_term(t, out) << std::endl;        
        lpvar j = m_lar_solver.external_to_local(ext);
        print_var(j, out);
    }
    return out;
}

std::string core::var_str(lpvar j) const {
    return is_monic_var(j)?
        (product_indices_str(m_emons[j].vars()) + (check_monic(m_emons[j])? """": ""_"")) : (std::string(""j"") + lp::T_to_string(j));        
}

std::ostream& core::print_term( const lp::lar_term& t, std::ostream& out) const {
    return lp::print_linear_combination_customized(
        t.coeffs_as_vector(),
        [this](lpvar j) { return var_str(j); },
        out);
}


void core::run_grobner() {
    unsigned& quota = m_nla_settings.grobner_quota();
    if (quota == 1) {
        return;
    }
    clear_and_resize_active_var_set(); 
    find_nl_cluster();

    lp_settings().stats().m_grobner_calls++;
    configure_grobner();
    m_pdd_grobner.saturate();
    bool conflict = false;
    unsigned n = m_pdd_grobner.number_of_conflicts_to_report();
    SASSERT(n > 0);
    for (auto eq : m_pdd_grobner.equations()) {
        if (check_pdd_eq(eq)) {
            conflict = true;
            if (--n == 0)
                break;
        }
    }
    if (conflict) {
        IF_VERBOSE(2, verbose_stream() << ""grobner conflict\\n"");
    }
    else {
        if (quota > 1)
            quota--;
        IF_VERBOSE(2, verbose_stream() << ""grobner miss, quota "" << quota <<  ""\\n"");
        IF_VERBOSE(4, diagnose_pdd_miss(verbose_stream()));
    }
}

void core::configure_grobner() {
    m_pdd_grobner.reset();
    try {
        set_level2var_for_grobner();
        for (unsigned i : m_rows) {
            add_row_to_grobner(m_lar_solver.A_r().m_rows[i]);
        }
    }
    catch (...) {
        IF_VERBOSE(2, verbose_stream() << ""pdd throw\\n"");
        return;
    }
#if 0
    IF_VERBOSE(2, m_pdd_grobner.display(verbose_stream()));
    dd::pdd_eval eval(m_pdd_manager);
    eval.var2val() = [&](unsigned j){ return val(j); };
    for (auto* e : m_pdd_grobner.equations()) {
        dd::pdd p = e->poly();
        rational v = eval(p);
        if (p.is_linear() && !eval(p).is_zero()) {
            IF_VERBOSE(0, verbose_stream() << ""violated linear constraint "" << p << ""\\n"");
        }
    }
#endif
   
    struct dd::solver::config cfg;
    cfg.m_max_steps = m_pdd_grobner.equations().size();
    cfg.m_max_simplified = m_nla_settings.grobner_max_simplified();
    cfg.m_eqs_growth = m_nla_settings.grobner_eqs_growth();
    cfg.m_expr_size_growth = m_nla_settings.grobner_expr_size_growth();
    cfg.m_expr_degree_growth = m_nla_settings.grobner_expr_degree_growth();
    cfg.m_number_of_conflicts_to_report = m_nla_settings.grobner_number_of_conflicts_to_report();
    m_pdd_grobner.set(cfg);
    m_pdd_grobner.adjust_cfg();
    m_pdd_manager.set_max_num_nodes(10000); // or something proportional to the number of initial nodes.
}

std::ostream& core::diagnose_pdd_miss(std::ostream& out) {

    // m_pdd_grobner.display(out);

    dd::pdd_eval eval;
    eval.var2val() = [&](unsigned j){ return val(j); };
    for (auto* e : m_pdd_grobner.equations()) {
        dd::pdd p = e->poly();
        rational v = eval(p);
        if (!v.is_zero()) {
            out << p << "" := "" << v << ""\\n"";
        }
    }  
  
    for (unsigned j = 0; j < m_lar_solver.number_of_vars(); ++j) {
        if (m_lar_solver.column_has_lower_bound(j) || m_lar_solver.column_has_upper_bound(j)) {
            out << j << "": ["";
                if (m_lar_solver.column_has_lower_bound(j)) out << m_lar_solver.get_lower_bound(j);
                out << "".."";
                if (m_lar_solver.column_has_upper_bound(j)) out << m_lar_solver.get_upper_bound(j);
                out << ""]\\n"";
        }
    }              
    return out;
}

bool core::check_pdd_eq(const dd::solver::equation* e) {
    auto& di = m_intervals.get_dep_intervals();
    dd::pdd_interval eval(di);
    eval.var2interval() = [this](lpvar j, bool deps, scoped_dep_interval& a) {
        if (deps) m_intervals.set_var_interval<dd::w_dep::with_deps>(j, a);
        else m_intervals.set_var_interval<dd::w_dep::without_deps>(j, a);
    };
    scoped_dep_interval i(di), i_wd(di);
    eval.get_interval<dd::w_dep::without_deps>(e->poly(), i);    
    if (!di.separated_from_zero(i))
        return false;
    eval.get_interval<dd::w_dep::with_deps>(e->poly(), i_wd);  
    std::function<void (const lp::explanation&)> f = [this](const lp::explanation& e) {
        new_lemma lemma(*this, ""pdd"");
        lemma &= e;
    };
    if (di.check_interval_for_conflict_on_zero(i_wd, e->dep(), f)) {
        lp_settings().stats().m_grobner_conflicts++;
        return true;
    }
    else {
        return false;
    }
}

void core::add_var_and_its_factors_to_q_and_collect_new_rows(lpvar j, svector<lpvar> & q) {
    if (active_var_set_contains(j) || var_is_fixed(j)) return;
    TRACE(""grobner"", tout << ""j = "" << j << "", "" << pp(j););
    const auto& matrix = m_lar_solver.A_r();
    insert_to_active_var_set(j);
    for (auto & s : matrix.m_columns[j]) {
        unsigned row = s.var();
        if (m_rows.contains(row)) continue;       
        if (matrix.m_rows[row].size() > m_nla_settings.grobner_row_length_limit()) {
            TRACE(""grobner"", tout << ""ignore the row "" << row << "" with the size "" << matrix.m_rows[row].size() << ""\\n"";); 
            continue;
        }
        m_rows.insert(row);
        for (auto& rc : matrix.m_rows[row]) {
            add_var_and_its_factors_to_q_and_collect_new_rows(rc.var(), q);
        }
    }

    if (!is_monic_var(j))
        return;

    const monic& m = emons()[j];
    for (auto fcn : factorization_factory_imp(m, *this)) {
        for (const factor& fc: fcn) {
            q.push_back(var(fc));
        }
    }            
}

const rational& core::val_of_fixed_var_with_deps(lpvar j, u_dependency*& dep) {
    unsigned lc, uc;
    m_lar_solver.get_bound_constraint_witnesses_for_column(j, lc, uc);
    dep = m_intervals.mk_join(dep, m_intervals.mk_leaf(lc));
    dep = m_intervals.mk_join(dep, m_intervals.mk_leaf(uc));
    return m_lar_solver.column_lower_bound(j).x;
}

dd::pdd core::pdd_expr(const rational& c, lpvar j, u_dependency*& dep) {
    if (m_nla_settings.grobner_subs_fixed() == 1 && var_is_fixed(j)) {
        return m_pdd_manager.mk_val(c * val_of_fixed_var_with_deps(j, dep));
    }

    if (m_nla_settings.grobner_subs_fixed() == 2 && var_is_fixed_to_zero(j)) {
        return m_pdd_manager.mk_val(val_of_fixed_var_with_deps(j, dep));
    }

    if (!is_monic_var(j))
        return c * m_pdd_manager.mk_var(j);

    u_dependency* zero_dep = dep;
    // j is a monic var
    dd::pdd r = m_pdd_manager.mk_val(c);
    const monic& m = emons()[j];
    for (lpvar k : m.vars()) {
        if (m_nla_settings.grobner_subs_fixed() && var_is_fixed(k)) {
            r *= m_pdd_manager.mk_val(val_of_fixed_var_with_deps(k, dep));
        } else if (m_nla_settings.grobner_subs_fixed() == 2 && var_is_fixed_to_zero(k)) {
            r = m_pdd_manager.mk_val(val_of_fixed_var_with_deps(k, zero_dep));
            dep = zero_dep;
            return r;
        } else {
            r *= m_pdd_manager.mk_var(k);
        }
    }
    return r;
}

void core::add_row_to_grobner(const vector<lp::row_cell<rational>> & row) {
    u_dependency *dep = nullptr;
    dd::pdd sum = m_pdd_manager.mk_val(rational(0));
    for (const auto &p : row) {
        sum  += pdd_expr(p.coeff(), p.var(), dep);
    }
    m_pdd_grobner.add(sum, dep);    
}


void core::find_nl_cluster() {
    prepare_rows_and_active_vars();
    svector<lpvar> q;
    for (lpvar j : m_to_refine) {        
        TRACE(""grobner"", print_monic(emons()[j], tout) << ""\\n"";);
        q.push_back(j);
    }
    
    while (!q.empty()) {
        lpvar j = q.back();        
        q.pop_back();
        add_var_and_its_factors_to_q_and_collect_new_rows(j, q);
    }
    TRACE(""grobner"", display_matrix_of_m_rows(tout););
}

void core::prepare_rows_and_active_vars() {
    m_rows.clear();
    m_rows.resize(m_lar_solver.row_count());
    clear_and_resize_active_var_set();
}


std::unordered_set<lpvar> core::get_vars_of_expr_with_opening_terms(const nex *e ) {
    auto ret = get_vars_of_expr(e);
    auto & ls = m_lar_solver;
    svector<lpvar> added;
    for (auto j : ret) {
        added.push_back(j);
    }
    for (unsigned i = 0; i < added.size(); ++i) {
        lpvar j = added[i];
        if (ls.column_corresponds_to_term(j)) {
            const auto& t = m_lar_solver.get_term(lp::tv::raw(ls.local_to_external(j)));
            for (auto p : t) {
                if (ret.find(p.column()) == ret.end()) {
                    added.push_back(p.column());
                    ret.insert(p.column());
                }
            }
        }
    }
    return ret;
}

void core::display_matrix_of_m_rows(std::ostream & out) const {
    const auto& matrix = m_lar_solver.A_r();
    out << m_rows.size() << "" rows"" <<""\\n"";
    out << ""the matrix\\n"";          
    for (const auto & r : matrix.m_rows) {
        print_row(r, out) << std::endl;
    }
}

void core::set_active_vars_weights(nex_creator& nc) {
    nc.set_number_of_vars(m_lar_solver.column_count());
    for (lpvar j : active_var_set()) {
        nc.set_var_weight(j, get_var_weight(j));
    }
}

void core::set_level2var_for_grobner() {
    unsigned n = m_lar_solver.column_count();
    unsigned_vector sorted_vars(n), weighted_vars(n);
    for (unsigned j = 0; j < n; j++) {
        sorted_vars[j] = j;
        weighted_vars[j] = get_var_weight(j);
    }
#if 1
    // potential update to weights
    for (unsigned j = 0; j < n; j++) {
        if (is_monic_var(j) && m_to_refine.contains(j)) {
            for (lpvar k : m_emons[j].vars()) {
                weighted_vars[k] += 6;
            }
        }
    }
#endif

    std::sort(sorted_vars.begin(), sorted_vars.end(), [&](unsigned a, unsigned b) {
                                                      unsigned wa = weighted_vars[a];
                                                      unsigned wb = weighted_vars[b];
                                                      return wa < wb || (wa == wb && a < b); });

    unsigned_vector l2v(n);
    for (unsigned j = 0; j < n; j++)
        l2v[j] = sorted_vars[j];

    m_pdd_manager.reset(l2v);
}

unsigned core::get_var_weight(lpvar j) const {
    unsigned k;
    switch (m_lar_solver.get_column_type(j)) {
        
    case lp::column_type::fixed:
        k = 0;
        break;
    case lp::column_type::boxed:
        k = 2;
        break;
    case lp::column_type::lower_bound:
    case lp::column_type::upper_bound:
        k = 4;
    case lp::column_type::free_column:
        k = 6;
        break;
    default:
        UNREACHABLE();
        break;
    }
    if (is_monic_var(j)) {
        k++;
        if (m_to_refine.contains(j)) {
            k++;
        }
    }
    return k;
}

bool core::is_nl_var(lpvar j) const {
    return is_monic_var(j) || m_emons.is_used_in_monic(j);
}

bool core::influences_nl_var(lpvar j) const {
    if (lp::tv::is_term(j))
        j = lp::tv::unmask_term(j);
    if (is_nl_var(j))
        return true;
    for (const auto & c : m_lar_solver.A_r().m_columns[j]) {
        lpvar basic_in_row = m_lar_solver.r_basis()[c.var()];
        if (is_nl_var(basic_in_row))
            return true;        
    }
    return false;
}

void core::collect_statistics(::statistics & st) {
    st.update(""arith-nla-explanations"", m_stats.m_nla_explanations);
    st.update(""arith-nla-lemmas"", m_stats.m_nla_lemmas);
    st.update(""arith-nra-calls"", m_stats.m_nra_calls);    
}


} // end of nla
",16253,True,3154.448230309783,median
"/*************************************************************************/
/*  tween.cpp                                                            */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                      https://godotengine.org                          */
/*************************************************************************/
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
/*                                                                       */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the       */
/* ""Software""), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/

#include ""tween.h""

#include ""core/method_bind_ext.gen.inc""

void Tween::_add_pending_command(StringName p_key, const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4, const Variant &p_arg5, const Variant &p_arg6, const Variant &p_arg7, const Variant &p_arg8, const Variant &p_arg9, const Variant &p_arg10) {

	// Add a new pending command and reference it
	pending_commands.push_back(PendingCommand());
	PendingCommand &cmd = pending_commands.back()->get();

	// Update the command with the target key
	cmd.key = p_key;

	// Determine command argument count
	int &count = cmd.args;
	if (p_arg10.get_type() != Variant::NIL)
		count = 10;
	else if (p_arg9.get_type() != Variant::NIL)
		count = 9;
	else if (p_arg8.get_type() != Variant::NIL)
		count = 8;
	else if (p_arg7.get_type() != Variant::NIL)
		count = 7;
	else if (p_arg6.get_type() != Variant::NIL)
		count = 6;
	else if (p_arg5.get_type() != Variant::NIL)
		count = 5;
	else if (p_arg4.get_type() != Variant::NIL)
		count = 4;
	else if (p_arg3.get_type() != Variant::NIL)
		count = 3;
	else if (p_arg2.get_type() != Variant::NIL)
		count = 2;
	else if (p_arg1.get_type() != Variant::NIL)
		count = 1;
	else
		count = 0;

	// Add the specified arguments to the command
	if (count > 0)
		cmd.arg[0] = p_arg1;
	if (count > 1)
		cmd.arg[1] = p_arg2;
	if (count > 2)
		cmd.arg[2] = p_arg3;
	if (count > 3)
		cmd.arg[3] = p_arg4;
	if (count > 4)
		cmd.arg[4] = p_arg5;
	if (count > 5)
		cmd.arg[5] = p_arg6;
	if (count > 6)
		cmd.arg[6] = p_arg7;
	if (count > 7)
		cmd.arg[7] = p_arg8;
	if (count > 8)
		cmd.arg[8] = p_arg9;
	if (count > 9)
		cmd.arg[9] = p_arg10;
}

void Tween::_process_pending_commands() {

	// For each pending command...
	for (List<PendingCommand>::Element *E = pending_commands.front(); E; E = E->next()) {

		// Get the command
		PendingCommand &cmd = E->get();
		Variant::CallError err;

		// Grab all of the arguments for the command
		Variant *arg[10] = {
			&cmd.arg[0],
			&cmd.arg[1],
			&cmd.arg[2],
			&cmd.arg[3],
			&cmd.arg[4],
			&cmd.arg[5],
			&cmd.arg[6],
			&cmd.arg[7],
			&cmd.arg[8],
			&cmd.arg[9],
		};

		// Execute the command (and retrieve any errors)
		this->call(cmd.key, (const Variant **)arg, cmd.args, err);
	}

	// Clear the pending commands
	pending_commands.clear();
}

bool Tween::_set(const StringName &p_name, const Variant &p_value) {

	// Set the correct attribute based on the given name
	String name = p_name;
	if (name == ""playback/speed"" || name == ""speed"") { // Backwards compatibility
		set_speed_scale(p_value);
		return true;

	} else if (name == ""playback/active"") {
		set_active(p_value);
		return true;

	} else if (name == ""playback/repeat"") {
		set_repeat(p_value);
		return true;
	}
	return false;
}

bool Tween::_get(const StringName &p_name, Variant &r_ret) const {

	// Get the correct attribute based on the given name
	String name = p_name;
	if (name == ""playback/speed"") { // Backwards compatibility
		r_ret = speed_scale;
		return true;

	} else if (name == ""playback/active"") {
		r_ret = is_active();
		return true;

	} else if (name == ""playback/repeat"") {
		r_ret = is_repeat();
		return true;
	}
	return false;
}

void Tween::_get_property_list(List<PropertyInfo> *p_list) const {
	// Add the property info for the Tween object
	p_list->push_back(PropertyInfo(Variant::BOOL, ""playback/active"", PROPERTY_HINT_NONE, """"));
	p_list->push_back(PropertyInfo(Variant::BOOL, ""playback/repeat"", PROPERTY_HINT_NONE, """"));
	p_list->push_back(PropertyInfo(Variant::REAL, ""playback/speed"", PROPERTY_HINT_RANGE, ""-64,64,0.01""));
}

void Tween::_notification(int p_what) {
	// What notification did we receive?
	switch (p_what) {

		case NOTIFICATION_ENTER_TREE: {
			// Are we not already active?
			if (!is_active()) {
				// Make sure that a previous process state was not saved
				// Only process if ""processing"" is set
				set_physics_process_internal(false);
				set_process_internal(false);
			}
		} break;

		case NOTIFICATION_READY: {
			// Do nothing
		} break;

		case NOTIFICATION_INTERNAL_PROCESS: {
			// Are we processing during physics time?
			if (tween_process_mode == TWEEN_PROCESS_PHYSICS)
				// Do nothing since we aren't aligned with physics when we should be
				break;

			// Should we update?
			if (is_active())
				// Update the tweens
				_tween_process(get_process_delta_time());
		} break;

		case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {
			// Are we processing during 'regular' time?
			if (tween_process_mode == TWEEN_PROCESS_IDLE)
				// Do nothing since we would only process during idle time
				break;

			// Should we update?
			if (is_active())
				// Update the tweens
				_tween_process(get_physics_process_delta_time());
		} break;

		case NOTIFICATION_EXIT_TREE: {
			// We've left the tree. Stop all tweens
			stop_all();
		} break;
	}
}

void Tween::_bind_methods() {
	// Bind getters and setters
	ClassDB::bind_method(D_METHOD(""is_active""), &Tween::is_active);
	ClassDB::bind_method(D_METHOD(""set_active"", ""active""), &Tween::set_active);

	ClassDB::bind_method(D_METHOD(""is_repeat""), &Tween::is_repeat);
	ClassDB::bind_method(D_METHOD(""set_repeat"", ""repeat""), &Tween::set_repeat);

	ClassDB::bind_method(D_METHOD(""set_speed_scale"", ""speed""), &Tween::set_speed_scale);
	ClassDB::bind_method(D_METHOD(""get_speed_scale""), &Tween::get_speed_scale);

	ClassDB::bind_method(D_METHOD(""set_tween_process_mode"", ""mode""), &Tween::set_tween_process_mode);
	ClassDB::bind_method(D_METHOD(""get_tween_process_mode""), &Tween::get_tween_process_mode);

	// Bind the various Tween control methods
	ClassDB::bind_method(D_METHOD(""start""), &Tween::start);
	ClassDB::bind_method(D_METHOD(""reset"", ""object"", ""key""), &Tween::reset, DEFVAL(""""));
	ClassDB::bind_method(D_METHOD(""reset_all""), &Tween::reset_all);
	ClassDB::bind_method(D_METHOD(""stop"", ""object"", ""key""), &Tween::stop, DEFVAL(""""));
	ClassDB::bind_method(D_METHOD(""stop_all""), &Tween::stop_all);
	ClassDB::bind_method(D_METHOD(""resume"", ""object"", ""key""), &Tween::resume, DEFVAL(""""));
	ClassDB::bind_method(D_METHOD(""resume_all""), &Tween::resume_all);
	ClassDB::bind_method(D_METHOD(""remove"", ""object"", ""key""), &Tween::remove, DEFVAL(""""));
	ClassDB::bind_method(D_METHOD(""_remove_by_uid"", ""uid""), &Tween::_remove_by_uid);
	ClassDB::bind_method(D_METHOD(""remove_all""), &Tween::remove_all);
	ClassDB::bind_method(D_METHOD(""seek"", ""time""), &Tween::seek);
	ClassDB::bind_method(D_METHOD(""tell""), &Tween::tell);
	ClassDB::bind_method(D_METHOD(""get_runtime""), &Tween::get_runtime);

	// Bind interpolation and follow methods
	ClassDB::bind_method(D_METHOD(""interpolate_property"", ""object"", ""property"", ""initial_val"", ""final_val"", ""duration"", ""trans_type"", ""ease_type"", ""delay""), &Tween::interpolate_property, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
	ClassDB::bind_method(D_METHOD(""interpolate_method"", ""object"", ""method"", ""initial_val"", ""final_val"", ""duration"", ""trans_type"", ""ease_type"", ""delay""), &Tween::interpolate_method, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
	ClassDB::bind_method(D_METHOD(""interpolate_callback"", ""object"", ""duration"", ""callback"", ""arg1"", ""arg2"", ""arg3"", ""arg4"", ""arg5""), &Tween::interpolate_callback, DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()));
	ClassDB::bind_method(D_METHOD(""interpolate_deferred_callback"", ""object"", ""duration"", ""callback"", ""arg1"", ""arg2"", ""arg3"", ""arg4"", ""arg5""), &Tween::interpolate_deferred_callback, DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()));
	ClassDB::bind_method(D_METHOD(""follow_property"", ""object"", ""property"", ""initial_val"", ""target"", ""target_property"", ""duration"", ""trans_type"", ""ease_type"", ""delay""), &Tween::follow_property, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
	ClassDB::bind_method(D_METHOD(""follow_method"", ""object"", ""method"", ""initial_val"", ""target"", ""target_method"", ""duration"", ""trans_type"", ""ease_type"", ""delay""), &Tween::follow_method, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
	ClassDB::bind_method(D_METHOD(""targeting_property"", ""object"", ""property"", ""initial"", ""initial_val"", ""final_val"", ""duration"", ""trans_type"", ""ease_type"", ""delay""), &Tween::targeting_property, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
	ClassDB::bind_method(D_METHOD(""targeting_method"", ""object"", ""method"", ""initial"", ""initial_method"", ""final_val"", ""duration"", ""trans_type"", ""ease_type"", ""delay""), &Tween::targeting_method, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));

	// Add the Tween signals
	ADD_SIGNAL(MethodInfo(""tween_started"", PropertyInfo(Variant::OBJECT, ""object""), PropertyInfo(Variant::NODE_PATH, ""key"")));
	ADD_SIGNAL(MethodInfo(""tween_step"", PropertyInfo(Variant::OBJECT, ""object""), PropertyInfo(Variant::NODE_PATH, ""key""), PropertyInfo(Variant::REAL, ""elapsed""), PropertyInfo(Variant::OBJECT, ""value"")));
	ADD_SIGNAL(MethodInfo(""tween_completed"", PropertyInfo(Variant::OBJECT, ""object""), PropertyInfo(Variant::NODE_PATH, ""key"")));
	ADD_SIGNAL(MethodInfo(""tween_all_completed""));

	// Add the properties and tie them to the getters and setters
	ADD_PROPERTY(PropertyInfo(Variant::BOOL, ""repeat""), ""set_repeat"", ""is_repeat"");
	ADD_PROPERTY(PropertyInfo(Variant::INT, ""playback_process_mode"", PROPERTY_HINT_ENUM, ""Physics,Idle""), ""set_tween_process_mode"", ""get_tween_process_mode"");
	ADD_PROPERTY(PropertyInfo(Variant::REAL, ""playback_speed"", PROPERTY_HINT_RANGE, ""-64,64,0.01""), ""set_speed_scale"", ""get_speed_scale"");

	// Bind Idle vs Physics process
	BIND_ENUM_CONSTANT(TWEEN_PROCESS_PHYSICS);
	BIND_ENUM_CONSTANT(TWEEN_PROCESS_IDLE);

	// Bind the Transition type constants
	BIND_ENUM_CONSTANT(TRANS_LINEAR);
	BIND_ENUM_CONSTANT(TRANS_SINE);
	BIND_ENUM_CONSTANT(TRANS_QUINT);
	BIND_ENUM_CONSTANT(TRANS_QUART);
	BIND_ENUM_CONSTANT(TRANS_QUAD);
	BIND_ENUM_CONSTANT(TRANS_EXPO);
	BIND_ENUM_CONSTANT(TRANS_ELASTIC);
	BIND_ENUM_CONSTANT(TRANS_CUBIC);
	BIND_ENUM_CONSTANT(TRANS_CIRC);
	BIND_ENUM_CONSTANT(TRANS_BOUNCE);
	BIND_ENUM_CONSTANT(TRANS_BACK);

	// Bind the easing constants
	BIND_ENUM_CONSTANT(EASE_IN);
	BIND_ENUM_CONSTANT(EASE_OUT);
	BIND_ENUM_CONSTANT(EASE_IN_OUT);
	BIND_ENUM_CONSTANT(EASE_OUT_IN);
}

Variant Tween::_get_initial_val(const InterpolateData &p_data) const {

	// What type of data are we interpolating?
	switch (p_data.type) {
		case INTER_PROPERTY:
		case INTER_METHOD:
		case FOLLOW_PROPERTY:
		case FOLLOW_METHOD:
			// Simply use the given initial value
			return p_data.initial_val;

		case TARGETING_PROPERTY:
		case TARGETING_METHOD: {
			// Get the object that is being targeted
			Object *object = ObjectDB::get_instance(p_data.target_id);
			ERR_FAIL_COND_V(object == NULL, p_data.initial_val);

			// Are we targeting a property or a method?
			Variant initial_val;
			if (p_data.type == TARGETING_PROPERTY) {
				// Get the property from the target object
				bool valid = false;
				initial_val = object->get_indexed(p_data.target_key, &valid);
				ERR_FAIL_COND_V(!valid, p_data.initial_val);
			} else {
				// Call the method and get the initial value from it
				Variant::CallError error;
				initial_val = object->call(p_data.target_key[0], NULL, 0, error);
				ERR_FAIL_COND_V(error.error != Variant::CallError::CALL_OK, p_data.initial_val);
			}
			return initial_val;
		}

		case INTER_CALLBACK:
			// Callback does not have a special initial value
			break;
	}
	// If we've made it here, just return the delta value as the initial value
	return p_data.delta_val;
}

Variant Tween::_get_final_val(const InterpolateData &p_data) const {
	switch (p_data.type) {
		case FOLLOW_PROPERTY:
		case FOLLOW_METHOD: {
			// Get the object that is being followed
			Object *target = ObjectDB::get_instance(p_data.target_id);
			ERR_FAIL_COND_V(target == NULL, p_data.initial_val);

			// We want to figure out the final value
			Variant final_val;
			if (p_data.type == FOLLOW_PROPERTY) {
				// Read the property as-is
				bool valid = false;
				final_val = target->get_indexed(p_data.target_key, &valid);
				ERR_FAIL_COND_V(!valid, p_data.initial_val);
			} else {
				// We're looking at a method. Call the method on the target object
				Variant::CallError error;
				final_val = target->call(p_data.target_key[0], NULL, 0, error);
				ERR_FAIL_COND_V(error.error != Variant::CallError::CALL_OK, p_data.initial_val);
			}

			// If we're looking at an INT value, instead convert it to a REAL
			// This is better for interpolation
			if (final_val.get_type() == Variant::INT) final_val = final_val.operator real_t();

			return final_val;
		}
		default: {
			// If we're not following a final value/method, use the final value from the data
			return p_data.final_val;
		}
	}
}

Variant &Tween::_get_delta_val(InterpolateData &p_data) {

	// What kind of data are we interpolating?
	switch (p_data.type) {
		case INTER_PROPERTY:
		case INTER_METHOD:
			// Simply return the given delta value
			return p_data.delta_val;

		case FOLLOW_PROPERTY:
		case FOLLOW_METHOD: {
			// We're following an object, so grab that instance
			Object *target = ObjectDB::get_instance(p_data.target_id);
			ERR_FAIL_COND_V(target == NULL, p_data.initial_val);

			// We want to figure out the final value
			Variant final_val;
			if (p_data.type == FOLLOW_PROPERTY) {
				// Read the property as-is
				bool valid = false;
				final_val = target->get_indexed(p_data.target_key, &valid);
				ERR_FAIL_COND_V(!valid, p_data.initial_val);
			} else {
				// We're looking at a method. Call the method on the target object
				Variant::CallError error;
				final_val = target->call(p_data.target_key[0], NULL, 0, error);
				ERR_FAIL_COND_V(error.error != Variant::CallError::CALL_OK, p_data.initial_val);
			}

			// If we're looking at an INT value, instead convert it to a REAL
			// This is better for interpolation
			if (final_val.get_type() == Variant::INT) final_val = final_val.operator real_t();

			// Calculate the delta based on the initial value and the final value
			_calc_delta_val(p_data.initial_val, final_val, p_data.delta_val);
			return p_data.delta_val;
		}

		case TARGETING_PROPERTY:
		case TARGETING_METHOD: {
			// Grab the initial value from the data to calculate delta
			Variant initial_val = _get_initial_val(p_data);

			// If we're looking at an INT value, instead convert it to a REAL
			// This is better for interpolation
			if (initial_val.get_type() == Variant::INT) initial_val = initial_val.operator real_t();

			// Calculate the delta based on the initial value and the final value
			_calc_delta_val(initial_val, p_data.final_val, p_data.delta_val);
			return p_data.delta_val;
		}

		case INTER_CALLBACK:
			// Callbacks have no special delta
			break;
	}
	// If we've made it here, use the initial value as the delta
	return p_data.initial_val;
}

Variant Tween::_run_equation(InterpolateData &p_data) {
	// Get the initial and delta values from the data
	Variant initial_val = _get_initial_val(p_data);
	Variant &delta_val = _get_delta_val(p_data);
	Variant result;

#define APPLY_EQUATION(element) \\
	r.element = _run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, i.element, d.element, p_data.duration);

	// What type of data are we interpolating?
	switch (initial_val.get_type()) {

		case Variant::BOOL:
			// Run the boolean specific equation (checking if it is at least 0.5)
			result = (_run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, initial_val, delta_val, p_data.duration)) >= 0.5;
			break;

		case Variant::INT:
			// Run the integer specific equation
			result = (int)_run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, (int)initial_val, (int)delta_val, p_data.duration);
			break;

		case Variant::REAL:
			// Run the REAL specific equation
			result = _run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, (real_t)initial_val, (real_t)delta_val, p_data.duration);
			break;

		case Variant::VECTOR2: {
			// Get vectors for initial and delta values
			Vector2 i = initial_val;
			Vector2 d = delta_val;
			Vector2 r;

			// Execute the equation and mutate the r vector
			// This uses the custom APPLY_EQUATION macro defined above
			APPLY_EQUATION(x);
			APPLY_EQUATION(y);
			result = r;
		} break;

		case Variant::RECT2: {
			// Get the Rect2 for initial and delta value
			Rect2 i = initial_val;
			Rect2 d = delta_val;
			Rect2 r;

			// Execute the equation for the position and size of Rect2
			APPLY_EQUATION(position.x);
			APPLY_EQUATION(position.y);
			APPLY_EQUATION(size.x);
			APPLY_EQUATION(size.y);
			result = r;
		} break;

		case Variant::VECTOR3: {
			// Get vectors for initial and delta values
			Vector3 i = initial_val;
			Vector3 d = delta_val;
			Vector3 r;

			// Execute the equation and mutate the r vector
			// This uses the custom APPLY_EQUATION macro defined above
			APPLY_EQUATION(x);
			APPLY_EQUATION(y);
			APPLY_EQUATION(z);
			result = r;
		} break;

		case Variant::TRANSFORM2D: {
			// Get the transforms for initial and delta values
			Transform2D i = initial_val;
			Transform2D d = delta_val;
			Transform2D r;

			// Execute the equation on the transforms and mutate the r transform
			// This uses the custom APPLY_EQUATION macro defined above
			APPLY_EQUATION(elements[0][0]);
			APPLY_EQUATION(elements[0][1]);
			APPLY_EQUATION(elements[1][0]);
			APPLY_EQUATION(elements[1][1]);
			APPLY_EQUATION(elements[2][0]);
			APPLY_EQUATION(elements[2][1]);
			result = r;
		} break;

		case Variant::QUAT: {
			// Get the quaternian for the initial and delta values
			Quat i = initial_val;
			Quat d = delta_val;
			Quat r;

			// Execute the equation on the quaternian values and mutate the r quaternian
			// This uses the custom APPLY_EQUATION macro defined above
			APPLY_EQUATION(x);
			APPLY_EQUATION(y);
			APPLY_EQUATION(z);
			APPLY_EQUATION(w);
			result = r;
		} break;

		case Variant::AABB: {
			// Get the AABB's for the initial and delta values
			AABB i = initial_val;
			AABB d = delta_val;
			AABB r;

			// Execute the equation for the position and size of the AABB's and mutate the r AABB
			// This uses the custom APPLY_EQUATION macro defined above
			APPLY_EQUATION(position.x);
			APPLY_EQUATION(position.y);
			APPLY_EQUATION(position.z);
			APPLY_EQUATION(size.x);
			APPLY_EQUATION(size.y);
			APPLY_EQUATION(size.z);
			result = r;
		} break;

		case Variant::BASIS: {
			// Get the basis for initial and delta values
			Basis i = initial_val;
			Basis d = delta_val;
			Basis r;

			// Execute the equation on all the basis and mutate the r basis
			// This uses the custom APPLY_EQUATION macro defined above
			APPLY_EQUATION(elements[0][0]);
			APPLY_EQUATION(elements[0][1]);
			APPLY_EQUATION(elements[0][2]);
			APPLY_EQUATION(elements[1][0]);
			APPLY_EQUATION(elements[1][1]);
			APPLY_EQUATION(elements[1][2]);
			APPLY_EQUATION(elements[2][0]);
			APPLY_EQUATION(elements[2][1]);
			APPLY_EQUATION(elements[2][2]);
			result = r;
		} break;

		case Variant::TRANSFORM: {
			// Get the transforms for the initial and delta values
			Transform i = initial_val;
			Transform d = delta_val;
			Transform r;

			// Execute the equation for each of the transforms and their origin and mutate the r transform
			// This uses the custom APPLY_EQUATION macro defined above
			APPLY_EQUATION(basis.elements[0][0]);
			APPLY_EQUATION(basis.elements[0][1]);
			APPLY_EQUATION(basis.elements[0][2]);
			APPLY_EQUATION(basis.elements[1][0]);
			APPLY_EQUATION(basis.elements[1][1]);
			APPLY_EQUATION(basis.elements[1][2]);
			APPLY_EQUATION(basis.elements[2][0]);
			APPLY_EQUATION(basis.elements[2][1]);
			APPLY_EQUATION(basis.elements[2][2]);
			APPLY_EQUATION(origin.x);
			APPLY_EQUATION(origin.y);
			APPLY_EQUATION(origin.z);
			result = r;
		} break;

		case Variant::COLOR: {
			// Get the Color for initial and delta value
			Color i = initial_val;
			Color d = delta_val;
			Color r;

			// Apply the equation on the Color RGBA, and mutate the r color
			// This uses the custom APPLY_EQUATION macro defined above
			APPLY_EQUATION(r);
			APPLY_EQUATION(g);
			APPLY_EQUATION(b);
			APPLY_EQUATION(a);
			result = r;
		} break;

		default: {
			// If unknown, just return the initial value
			result = initial_val;
		} break;
	};
#undef APPLY_EQUATION
	// Return the result that was computed
	return result;
}

bool Tween::_apply_tween_value(InterpolateData &p_data, Variant &value) {

	// Get the object we want to apply the new value to
	Object *object = ObjectDB::get_instance(p_data.id);
	ERR_FAIL_COND_V(object == NULL, false);

	// What kind of data are we mutating?
	switch (p_data.type) {

		case INTER_PROPERTY:
		case FOLLOW_PROPERTY:
		case TARGETING_PROPERTY: {
			// Simply set the property on the object
			bool valid = false;
			object->set_indexed(p_data.key, value, &valid);
			return valid;
		}

		case INTER_METHOD:
		case FOLLOW_METHOD:
		case TARGETING_METHOD: {
			// We want to call the method on the target object
			Variant::CallError error;

			// Do we have a non-nil value passed in?
			if (value.get_type() != Variant::NIL) {
				// Pass it as an argument to the function call
				Variant *arg[1] = { &value };
				object->call(p_data.key[0], (const Variant **)arg, 1, error);
			} else {
				// Don't pass any argument
				object->call(p_data.key[0], NULL, 0, error);
			}

			// Did we get an error from the function call?
			return error.error == Variant::CallError::CALL_OK;
		}

		case INTER_CALLBACK:
			// Nothing to apply for a callback
			break;
	};
	// No issues found!
	return true;
}

void Tween::_tween_process(float p_delta) {
	// Process all of the pending commands
	_process_pending_commands();

	// If the scale is 0, make no progress on the tweens
	if (speed_scale == 0)
		return;

	// Update the delta and whether we are pending an update
	p_delta *= speed_scale;
	pending_update++;

	// Are we repeating the interpolations?
	if (repeat) {
		// For each interpolation...
		bool repeats_finished = true;
		for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
			// Get the data from it
			InterpolateData &data = E->get();

			// Is not finished?
			if (!data.finish) {
				// We aren't finished yet, no need to check the rest
				repeats_finished = false;
				break;
			}
		}

		// If we are all finished, we can reset all of the tweens
		if (repeats_finished)
			reset_all();
	}

	// Are all of the tweens complete?
	bool all_finished = true;

	// For each tween we wish to interpolate...
	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {

		// Get the data from it
		InterpolateData &data = E->get();

		// Track if we hit one that isn't finished yet
		all_finished = all_finished && data.finish;

		// Is the data not active or already finished? No need to go any further
		if (!data.active || data.finish)
			continue;

		// Get the target object for this interpolation
		Object *object = ObjectDB::get_instance(data.id);
		if (object == NULL)
			continue;

		// Are we still delaying this tween?
		bool prev_delaying = data.elapsed <= data.delay;
		data.elapsed += p_delta;
		if (data.elapsed < data.delay)
			continue;
		else if (prev_delaying) {
			// We can apply the tween's value to the data and emit that the tween has started
			_apply_tween_value(data, data.initial_val);
			emit_signal(""tween_started"", object, NodePath(Vector<StringName>(), data.key, false));
		}

		// Are we at the end of the tween?
		if (data.elapsed > (data.delay + data.duration)) {
			// Set the elapsed time to the end and mark this one as finished
			data.elapsed = data.delay + data.duration;
			data.finish = true;
		}

		// Are we interpolating a callback?
		if (data.type == INTER_CALLBACK) {
			// Is the tween completed?
			if (data.finish) {
				// Are we calling this callback deferred or immediately?
				if (data.call_deferred) {
					// Run the deferred function callback, applying the correct number of arguments
					switch (data.args) {
						case 0:
							object->call_deferred(data.key[0]);
							break;
						case 1:
							object->call_deferred(data.key[0], data.arg[0]);
							break;
						case 2:
							object->call_deferred(data.key[0], data.arg[0], data.arg[1]);
							break;
						case 3:
							object->call_deferred(data.key[0], data.arg[0], data.arg[1], data.arg[2]);
							break;
						case 4:
							object->call_deferred(data.key[0], data.arg[0], data.arg[1], data.arg[2], data.arg[3]);
							break;
						case 5:
							object->call_deferred(data.key[0], data.arg[0], data.arg[1], data.arg[2], data.arg[3], data.arg[4]);
							break;
					}
				} else {
					// Call the function directly with the arguments
					Variant::CallError error;
					Variant *arg[5] = {
						&data.arg[0],
						&data.arg[1],
						&data.arg[2],
						&data.arg[3],
						&data.arg[4],
					};
					object->call(data.key[0], (const Variant **)arg, data.args, error);
				}
			}
		} else {
			// We can apply the value directly
			Variant result = _run_equation(data);
			_apply_tween_value(data, result);

			// Emit that the tween has taken a step
			emit_signal(""tween_step"", object, NodePath(Vector<StringName>(), data.key, false), data.elapsed, result);
		}

		// Is the tween now finished?
		if (data.finish) {
			// Set it to the final value directly
			Variant final_val = _get_final_val(data);
			_apply_tween_value(data, final_val);

			// Mark the tween as completed and emit the signal
			data.elapsed = 0;
			emit_signal(""tween_completed"", object, NodePath(Vector<StringName>(), data.key, false));

			// If we are not repeating the tween, remove it
			if (!repeat)
				call_deferred(""_remove_by_uid"", data.uid);
		} else if (!repeat) {
			// Check whether all tweens are finished
			all_finished = all_finished && data.finish;
		}
	}
	// One less update left to go
	pending_update--;

	// If all tweens are completed, we no longer need to be active
	if (all_finished) {
		set_active(false);
		emit_signal(""tween_all_completed"");
	}
}

void Tween::set_tween_process_mode(TweenProcessMode p_mode) {
	tween_process_mode = p_mode;
}

Tween::TweenProcessMode Tween::get_tween_process_mode() const {
	return tween_process_mode;
}

bool Tween::is_active() const {
	return is_processing_internal() || is_physics_processing_internal();
}

void Tween::set_active(bool p_active) {
	// Do nothing if it's the same active mode that we currently are
	if (is_active() == p_active)
		return;

	// Depending on physics or idle, set processing
	switch (tween_process_mode) {
		case TWEEN_PROCESS_IDLE: set_process_internal(p_active); break;
		case TWEEN_PROCESS_PHYSICS: set_physics_process_internal(p_active); break;
	}
}

bool Tween::is_repeat() const {
	return repeat;
}

void Tween::set_repeat(bool p_repeat) {
	repeat = p_repeat;
}

void Tween::set_speed_scale(float p_speed) {
	speed_scale = p_speed;
}

float Tween::get_speed_scale() const {
	return speed_scale;
}

bool Tween::start() {

	ERR_FAIL_COND_V_MSG(!is_inside_tree(), false, ""Tween was not added to the SceneTree!"");

	// Are there any pending updates?
	if (pending_update != 0) {
		// Start the tweens after deferring
		call_deferred(""start"");
		return true;
	}

	// We want to be activated
	set_active(true);
	return true;
}

bool Tween::reset(Object *p_object, StringName p_key) {
	// Find all interpolations that use the same object and target string
	pending_update++;
	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
		// Get the target object
		InterpolateData &data = E->get();
		Object *object = ObjectDB::get_instance(data.id);
		if (object == NULL)
			continue;

		// Do we have the correct object and key?
		if (object == p_object && (data.concatenated_key == p_key || p_key == """")) {
			// Reset the tween to the initial state
			data.elapsed = 0;
			data.finish = false;

			// Also apply the initial state if there isn't a delay
			if (data.delay == 0)
				_apply_tween_value(data, data.initial_val);
		}
	}
	pending_update--;
	return true;
}

bool Tween::reset_all() {
	// Go through all interpolations
	pending_update++;
	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
		// Get the target data and set it back to the initial state
		InterpolateData &data = E->get();
		data.elapsed = 0;
		data.finish = false;

		// If there isn't a delay, apply the value to the object
		if (data.delay == 0)
			_apply_tween_value(data, data.initial_val);
	}
	pending_update--;
	return true;
}

bool Tween::stop(Object *p_object, StringName p_key) {
	// Find the tween that has the given target object and string key
	pending_update++;
	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {

		// Get the object the tween is targeting
		InterpolateData &data = E->get();
		Object *object = ObjectDB::get_instance(data.id);
		if (object == NULL)
			continue;

		// Is this the correct object and does it have the given key?
		if (object == p_object && (data.concatenated_key == p_key || p_key == """"))
			// Disable the tween
			data.active = false;
	}
	pending_update--;
	return true;
}

bool Tween::stop_all() {
	// We no longer need to be active since all tweens have been stopped
	set_active(false);

	// For each interpolation...
	pending_update++;
	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
		// Simply set it inactive
		InterpolateData &data = E->get();
		data.active = false;
	}
	pending_update--;
	return true;
}

bool Tween::resume(Object *p_object, StringName p_key) {
	// We need to be activated
	// TODO: What if no tween is found??
	set_active(true);

	// Find the tween that uses the given target object and string key
	pending_update++;
	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
		// Grab the object
		InterpolateData &data = E->get();
		Object *object = ObjectDB::get_instance(data.id);
		if (object == NULL)
			continue;

		// If the object and string key match, activate it
		if (object == p_object && (data.concatenated_key == p_key || p_key == """"))
			data.active = true;
	}
	pending_update--;
	return true;
}

bool Tween::resume_all() {
	// Set ourselves active so we can process tweens
	// TODO: What if there are no tweens? We get set to active for no reason!
	set_active(true);

	// For each interpolation...
	pending_update++;
	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
		// Simply grab it and set it to active
		InterpolateData &data = E->get();
		data.active = true;
	}
	pending_update--;
	return true;
}

bool Tween::remove(Object *p_object, StringName p_key) {
	// If we are still updating, call this function again later
	if (pending_update != 0) {
		call_deferred(""remove"", p_object, p_key);
		return true;
	}

	// For each interpolation...
	List<List<InterpolateData>::Element *> for_removal;
	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
		// Get the target object
		InterpolateData &data = E->get();
		Object *object = ObjectDB::get_instance(data.id);
		if (object == NULL)
			continue;

		// If the target object and string key match, queue it for removal
		if (object == p_object && (data.concatenated_key == p_key || p_key == """")) {
			for_removal.push_back(E);
		}
	}

	// For each interpolation we wish to remove...
	for (List<List<InterpolateData>::Element *>::Element *E = for_removal.front(); E; E = E->next()) {
		// Erase it
		interpolates.erase(E->get());
	}
	return true;
}

void Tween::_remove_by_uid(int uid) {
	// If we are still updating, call this function again later
	if (pending_update != 0) {
		call_deferred(""_remove_by_uid"", uid);
		return;
	}

	// Find the interpolation that matches the given UID
	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
		if (uid == E->get().uid) {
			// It matches, erase it and stop looking
			E->erase();
			break;
		}
	}
}

void Tween::_push_interpolate_data(InterpolateData &p_data) {
	pending_update++;

	// Add the new interpolation
	p_data.uid = ++uid;
	interpolates.push_back(p_data);

	pending_update--;
}

bool Tween::remove_all() {
	// If we are still updating, call this function again later
	if (pending_update != 0) {
		call_deferred(""remove_all"");
		return true;
	}
	// We no longer need to be active
	set_active(false);

	// Clear out all interpolations and reset the uid
	interpolates.clear();
	uid = 0;

	return true;
}

bool Tween::seek(real_t p_time) {
	// Go through each interpolation...
	pending_update++;
	for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
		// Get the target data
		InterpolateData &data = E->get();

		// Update the elapsed data to be set to the target time
		data.elapsed = p_time;

		// Are we at the end?
		if (data.elapsed < data.delay) {
			// There is still time left to go
			data.finish = false;
			continue;
		} else if (data.elapsed >= (data.delay + data.duration)) {
			// We are past the end of it, set the elapsed time to the end and mark as finished
			data.elapsed = (data.delay + data.duration);
			data.finish = true;
		} else {
			// We are not finished with this interpolation yet
			data.finish = false;
		}

		// If we are a callback, do nothing special
		if (data.type == INTER_CALLBACK) {
			continue;
		}

		// Run the equation on the data and apply the value
		Variant result = _run_equation(data);
		_apply_tween_value(data, result);
	}
	pending_update--;
	return true;
}

real_t Tween::tell() const {
	// We want to grab the position of the furthest along tween
	pending_update++;
	real_t pos = 0;

	// For each interpolation...
	for (const List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
		// Get the data and figure out if it's position is further along than the previous ones
		const InterpolateData &data = E->get();
		if (data.elapsed > pos)
			// Save it if so
			pos = data.elapsed;
	}
	pending_update--;
	return pos;
}

real_t Tween::get_runtime() const {
	// If the tween isn't moving, it'll last forever
	if (speed_scale == 0) {
		return INFINITY;
	}

	pending_update++;

	// For each interpolation...
	real_t runtime = 0;
	for (const List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
		// Get the tween data and see if it's runtime is greater than the previous tweens
		const InterpolateData &data = E->get();
		real_t t = data.delay + data.duration;
		if (t > runtime)
			// This is the longest running tween
			runtime = t;
	}
	pending_update--;

	// Adjust the runtime for the current speed scale
	return runtime / speed_scale;
}

bool Tween::_calc_delta_val(const Variant &p_initial_val, const Variant &p_final_val, Variant &p_delta_val) {

	// Get the initial, final, and delta values
	const Variant &initial_val = p_initial_val;
	const Variant &final_val = p_final_val;
	Variant &delta_val = p_delta_val;

	// What kind of data are we interpolating?
	switch (initial_val.get_type()) {

		case Variant::BOOL:
			// We'll treat booleans just like integers
		case Variant::INT:
			// Compute the integer delta
			delta_val = (int)final_val - (int)initial_val;
			break;

		case Variant::REAL:
			// Convert to REAL and find the delta
			delta_val = (real_t)final_val - (real_t)initial_val;
			break;

		case Variant::VECTOR2:
			// Convert to Vectors and find the delta
			delta_val = final_val.operator Vector2() - initial_val.operator Vector2();
			break;

		case Variant::RECT2: {
			// Build a new Rect2 and use the new position and sizes to make a delta
			Rect2 i = initial_val;
			Rect2 f = final_val;
			delta_val = Rect2(f.position - i.position, f.size - i.size);
		} break;

		case Variant::VECTOR3:
			// Convert to Vectors and find the delta
			delta_val = final_val.operator Vector3() - initial_val.operator Vector3();
			break;

		case Variant::TRANSFORM2D: {
			// Build a new transform which is the difference between the initial and final values
			Transform2D i = initial_val;
			Transform2D f = final_val;
			Transform2D d = Transform2D();
			d[0][0] = f.elements[0][0] - i.elements[0][0];
			d[0][1] = f.elements[0][1] - i.elements[0][1];
			d[1][0] = f.elements[1][0] - i.elements[1][0];
			d[1][1] = f.elements[1][1] - i.elements[1][1];
			d[2][0] = f.elements[2][0] - i.elements[2][0];
			d[2][1] = f.elements[2][1] - i.elements[2][1];
			delta_val = d;
		} break;

		case Variant::QUAT:
			// Convert to quaternianls and find the delta
			delta_val = final_val.operator Quat() - initial_val.operator Quat();
			break;

		case Variant::AABB: {
			// Build a new AABB and use the new position and sizes to make a delta
			AABB i = initial_val;
			AABB f = final_val;
			delta_val = AABB(f.position - i.position, f.size - i.size);
		} break;

		case Variant::BASIS: {
			// Build a new basis which is the delta between the initial and final values
			Basis i = initial_val;
			Basis f = final_val;
			delta_val = Basis(f.elements[0][0] - i.elements[0][0],
					f.elements[0][1] - i.elements[0][1],
					f.elements[0][2] - i.elements[0][2],
					f.elements[1][0] - i.elements[1][0],
					f.elements[1][1] - i.elements[1][1],
					f.elements[1][2] - i.elements[1][2],
					f.elements[2][0] - i.elements[2][0],
					f.elements[2][1] - i.elements[2][1],
					f.elements[2][2] - i.elements[2][2]);
		} break;

		case Variant::TRANSFORM: {
			// Build a new transform which is the difference between the initial and final values
			Transform i = initial_val;
			Transform f = final_val;
			Transform d;
			d.set(f.basis.elements[0][0] - i.basis.elements[0][0],
					f.basis.elements[0][1] - i.basis.elements[0][1],
					f.basis.elements[0][2] - i.basis.elements[0][2],
					f.basis.elements[1][0] - i.basis.elements[1][0],
					f.basis.elements[1][1] - i.basis.elements[1][1],
					f.basis.elements[1][2] - i.basis.elements[1][2],
					f.basis.elements[2][0] - i.basis.elements[2][0],
					f.basis.elements[2][1] - i.basis.elements[2][1],
					f.basis.elements[2][2] - i.basis.elements[2][2],
					f.origin.x - i.origin.x,
					f.origin.y - i.origin.y,
					f.origin.z - i.origin.z);

			delta_val = d;
		} break;

		case Variant::COLOR: {
			// Make a new color which is the difference between each the color's RGBA attributes
			Color i = initial_val;
			Color f = final_val;
			delta_val = Color(f.r - i.r, f.g - i.g, f.b - i.b, f.a - i.a);
		} break;

		default: {
			static Variant::Type supported_types[] = {
				Variant::BOOL,
				Variant::INT,
				Variant::REAL,
				Variant::VECTOR2,
				Variant::RECT2,
				Variant::VECTOR3,
				Variant::TRANSFORM2D,
				Variant::QUAT,
				Variant::AABB,
				Variant::BASIS,
				Variant::TRANSFORM,
				Variant::COLOR,
			};

			int length = *(&supported_types + 1) - supported_types;
			String error_msg = ""Invalid parameter type. Supported types are: "";
			for (int i = 0; i < length; i++) {
				if (i != 0) {
					error_msg += "", "";
				}
				error_msg += Variant::get_type_name(supported_types[i]);
			}
			error_msg += ""."";
			ERR_PRINT(error_msg);
			return false;
		}
	};
	return true;
}

bool Tween::_build_interpolation(InterpolateType p_interpolation_type, Object *p_object, NodePath *p_property, StringName *p_method, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {

	// TODO: Add initialization+implementation for remaining interpolation types
	// TODO: Fix this method's organization to take advantage of the type

	// Make a new interpolation data
	InterpolateData data;
	data.active = true;
	data.type = p_interpolation_type;
	data.finish = false;
	data.elapsed = 0;

	// Validate and apply interpolation data

	// Give it the object
	ERR_FAIL_COND_V_MSG(p_object == NULL, false, ""Invalid object provided to Tween."");
	ERR_FAIL_COND_V_MSG(!ObjectDB::instance_validate(p_object), false, ""Invalid object provided to Tween."");
	data.id = p_object->get_instance_id();

	// Validate the initial and final values
	ERR_FAIL_COND_V_MSG(p_initial_val.get_type() != p_final_val.get_type(), false, ""Initial value type '"" + Variant::get_type_name(p_initial_val.get_type()) + ""' does not match final value type '"" + Variant::get_type_name(p_final_val.get_type()) + ""'."");
	data.initial_val = p_initial_val;
	data.final_val = p_final_val;

	// Check the Duration
	ERR_FAIL_COND_V_MSG(p_duration < 0, false, ""Only non-negative duration values allowed in Tweens."");
	data.duration = p_duration;

	// Tween Delay
	ERR_FAIL_COND_V_MSG(p_delay < 0, false, ""Only non-negative delay values allowed in Tweens."");
	data.delay = p_delay;

	// Transition type
	ERR_FAIL_COND_V_MSG(p_trans_type < 0 || p_trans_type >= TRANS_COUNT, false, ""Invalid transition type provided to Tween."");
	data.trans_type = p_trans_type;

	// Easing type
	ERR_FAIL_COND_V_MSG(p_ease_type < 0 || p_ease_type >= EASE_COUNT, false, ""Invalid easing type provided to Tween."");
	data.ease_type = p_ease_type;

	// Is the property defined?
	if (p_property) {
		// Check that the object actually contains the given property
		bool prop_valid = false;
		p_object->get_indexed(p_property->get_subnames(), &prop_valid);
		ERR_FAIL_COND_V_MSG(!prop_valid, false, ""Tween target object has no property named: "" + p_property->get_concatenated_subnames() + ""."");

		data.key = p_property->get_subnames();
		data.concatenated_key = p_property->get_concatenated_subnames();
	}

	// Is the method defined?
	if (p_method) {
		// Does the object even have the requested method?
		ERR_FAIL_COND_V_MSG(!p_object->has_method(*p_method), false, ""Tween target object has no method named: "" + *p_method + ""."");

		data.key.push_back(*p_method);
		data.concatenated_key = *p_method;
	}

	// Is there not a valid delta?
	if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val))
		return false;

	// Add this interpolation to the total
	_push_interpolate_data(data);
	return true;
}

bool Tween::interpolate_property(Object *p_object, NodePath p_property, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
	// If we are busy updating, call this function again later
	if (pending_update != 0) {
		_add_pending_command(""interpolate_property"", p_object, p_property, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
		return true;
	}

	// Get the property from the node path
	p_property = p_property.get_as_property_path();

	// If no initial value given, grab the initial value from the object
	// TODO: Is this documented? This is very useful and removes a lot of clutter from tweens!
	if (p_initial_val.get_type() == Variant::NIL) p_initial_val = p_object->get_indexed(p_property.get_subnames());

	// Convert any integers into REALs as they are better for interpolation
	if (p_initial_val.get_type() == Variant::INT) p_initial_val = p_initial_val.operator real_t();
	if (p_final_val.get_type() == Variant::INT) p_final_val = p_final_val.operator real_t();

	// Build the interpolation data
	bool result = _build_interpolation(INTER_PROPERTY, p_object, &p_property, NULL, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
	return result;
}

bool Tween::interpolate_method(Object *p_object, StringName p_method, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
	// If we are busy updating, call this function again later
	if (pending_update != 0) {
		_add_pending_command(""interpolate_method"", p_object, p_method, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
		return true;
	}

	// Convert any integers into REALs as they are better for interpolation
	if (p_initial_val.get_type() == Variant::INT) p_initial_val = p_initial_val.operator real_t();
	if (p_final_val.get_type() == Variant::INT) p_final_val = p_final_val.operator real_t();

	// Build the interpolation data
	bool result = _build_interpolation(INTER_METHOD, p_object, NULL, &p_method, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
	return result;
}

bool Tween::interpolate_callback(Object *p_object, real_t p_duration, String p_callback, VARIANT_ARG_DECLARE) {
	// If we are already updating, call this function again later
	if (pending_update != 0) {
		_add_pending_command(""interpolate_callback"", p_object, p_duration, p_callback, p_arg1, p_arg2, p_arg3, p_arg4, p_arg5);
		return true;
	}

	// Check that the target object is valid
	ERR_FAIL_COND_V(p_object == NULL, false);
	ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_object), false);

	// Duration cannot be negative
	ERR_FAIL_COND_V(p_duration < 0, false);

	// Check whether the object even has the callback
	ERR_FAIL_COND_V_MSG(!p_object->has_method(p_callback), false, ""Object has no callback named: "" + p_callback + ""."");

	// Build a new InterpolationData
	InterpolateData data;
	data.active = true;
	data.type = INTER_CALLBACK;
	data.finish = false;
	data.call_deferred = false;
	data.elapsed = 0;

	// Give the data it's configuration
	data.id = p_object->get_instance_id();
	data.key.push_back(p_callback);
	data.concatenated_key = p_callback;
	data.duration = p_duration;
	data.delay = 0;

	// Add arguments to the interpolation
	int args = 0;
	if (p_arg5.get_type() != Variant::NIL)
		args = 5;
	else if (p_arg4.get_type() != Variant::NIL)
		args = 4;
	else if (p_arg3.get_type() != Variant::NIL)
		args = 3;
	else if (p_arg2.get_type() != Variant::NIL)
		args = 2;
	else if (p_arg1.get_type() != Variant::NIL)
		args = 1;
	else
		args = 0;

	data.args = args;
	data.arg[0] = p_arg1;
	data.arg[1] = p_arg2;
	data.arg[2] = p_arg3;
	data.arg[3] = p_arg4;
	data.arg[4] = p_arg5;

	// Add the new interpolation
	_push_interpolate_data(data);
	return true;
}

bool Tween::interpolate_deferred_callback(Object *p_object, real_t p_duration, String p_callback, VARIANT_ARG_DECLARE) {
	// If we are already updating, call this function again later
	if (pending_update != 0) {
		_add_pending_command(""interpolate_deferred_callback"", p_object, p_duration, p_callback, p_arg1, p_arg2, p_arg3, p_arg4, p_arg5);
		return true;
	}

	// Check that the target object is valid
	ERR_FAIL_COND_V(p_object == NULL, false);
	ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_object), false);

	// No negative durations allowed
	ERR_FAIL_COND_V(p_duration < 0, false);

	// Confirm the callback exists on the object
	ERR_FAIL_COND_V_MSG(!p_object->has_method(p_callback), false, ""Object has no callback named: "" + p_callback + ""."");

	// Create a new InterpolateData for the callback
	InterpolateData data;
	data.active = true;
	data.type = INTER_CALLBACK;
	data.finish = false;
	data.call_deferred = true;
	data.elapsed = 0;

	// Give the data it's configuration
	data.id = p_object->get_instance_id();
	data.key.push_back(p_callback);
	data.concatenated_key = p_callback;
	data.duration = p_duration;
	data.delay = 0;

	// Collect arguments for the callback
	int args = 0;
	if (p_arg5.get_type() != Variant::NIL)
		args = 5;
	else if (p_arg4.get_type() != Variant::NIL)
		args = 4;
	else if (p_arg3.get_type() != Variant::NIL)
		args = 3;
	else if (p_arg2.get_type() != Variant::NIL)
		args = 2;
	else if (p_arg1.get_type() != Variant::NIL)
		args = 1;
	else
		args = 0;

	data.args = args;
	data.arg[0] = p_arg1;
	data.arg[1] = p_arg2;
	data.arg[2] = p_arg3;
	data.arg[3] = p_arg4;
	data.arg[4] = p_arg5;

	// Add the new interpolation
	_push_interpolate_data(data);
	return true;
}

bool Tween::follow_property(Object *p_object, NodePath p_property, Variant p_initial_val, Object *p_target, NodePath p_target_property, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
	// If we are already updating, call this function again later
	if (pending_update != 0) {
		_add_pending_command(""follow_property"", p_object, p_property, p_initial_val, p_target, p_target_property, p_duration, p_trans_type, p_ease_type, p_delay);
		return true;
	}

	// Get the two properties from their paths
	p_property = p_property.get_as_property_path();
	p_target_property = p_target_property.get_as_property_path();

	// If no initial value is given, grab it from the source object
	// TODO: Is this documented? It's really helpful for decluttering tweens
	if (p_initial_val.get_type() == Variant::NIL) p_initial_val = p_object->get_indexed(p_property.get_subnames());

	// Convert initial INT values to REAL as they are better for interpolation
	if (p_initial_val.get_type() == Variant::INT) p_initial_val = p_initial_val.operator real_t();

	// Confirm the source and target objects are valid
	ERR_FAIL_COND_V(p_object == NULL, false);
	ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_object), false);
	ERR_FAIL_COND_V(p_target == NULL, false);
	ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_target), false);

	// No negative durations
	ERR_FAIL_COND_V(p_duration < 0, false);

	// Ensure transition and easing types are valid
	ERR_FAIL_COND_V(p_trans_type < 0 || p_trans_type >= TRANS_COUNT, false);
	ERR_FAIL_COND_V(p_ease_type < 0 || p_ease_type >= EASE_COUNT, false);

	// No negative delays
	ERR_FAIL_COND_V(p_delay < 0, false);

	// Confirm the source and target objects have the desired properties
	bool prop_valid = false;
	p_object->get_indexed(p_property.get_subnames(), &prop_valid);
	ERR_FAIL_COND_V(!prop_valid, false);

	bool target_prop_valid = false;
	Variant target_val = p_target->get_indexed(p_target_property.get_subnames(), &target_prop_valid);
	ERR_FAIL_COND_V(!target_prop_valid, false);

	// Convert target INT to REAL since it is better for interpolation
	if (target_val.get_type() == Variant::INT) target_val = target_val.operator real_t();

	// Verify that the target value and initial value are the same type
	ERR_FAIL_COND_V(target_val.get_type() != p_initial_val.get_type(), false);

	// Create a new InterpolateData
	InterpolateData data;
	data.active = true;
	data.type = FOLLOW_PROPERTY;
	data.finish = false;
	data.elapsed = 0;

	// Give the InterpolateData it's configuration
	data.id = p_object->get_instance_id();
	data.key = p_property.get_subnames();
	data.concatenated_key = p_property.get_concatenated_subnames();
	data.initial_val = p_initial_val;
	data.target_id = p_target->get_instance_id();
	data.target_key = p_target_property.get_subnames();
	data.duration = p_duration;
	data.trans_type = p_trans_type;
	data.ease_type = p_ease_type;
	data.delay = p_delay;

	// Add the interpolation
	_push_interpolate_data(data);
	return true;
}

bool Tween::follow_method(Object *p_object, StringName p_method, Variant p_initial_val, Object *p_target, StringName p_target_method, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
	// If we are currently updating, call this function again later
	if (pending_update != 0) {
		_add_pending_command(""follow_method"", p_object, p_method, p_initial_val, p_target, p_target_method, p_duration, p_trans_type, p_ease_type, p_delay);
		return true;
	}
	// Convert initial INT values to REAL as they are better for interpolation
	if (p_initial_val.get_type() == Variant::INT) p_initial_val = p_initial_val.operator real_t();

	// Verify the source and target objects are valid
	ERR_FAIL_COND_V(p_object == NULL, false);
	ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_object), false);
	ERR_FAIL_COND_V(p_target == NULL, false);
	ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_target), false);

	// No negative durations
	ERR_FAIL_COND_V(p_duration < 0, false);

	// Ensure that the transition and ease types are valid
	ERR_FAIL_COND_V(p_trans_type < 0 || p_trans_type >= TRANS_COUNT, false);
	ERR_FAIL_COND_V(p_ease_type < 0 || p_ease_type >= EASE_COUNT, false);

	// No negative delays
	ERR_FAIL_COND_V(p_delay < 0, false);

	// Confirm both objects have the target methods
	ERR_FAIL_COND_V_MSG(!p_object->has_method(p_method), false, ""Object has no method named: "" + p_method + ""."");
	ERR_FAIL_COND_V_MSG(!p_target->has_method(p_target_method), false, ""Target has no method named: "" + p_target_method + ""."");

	// Call the method to get the target value
	Variant::CallError error;
	Variant target_val = p_target->call(p_target_method, NULL, 0, error);
	ERR_FAIL_COND_V(error.error != Variant::CallError::CALL_OK, false);

	// Convert target INT values to REAL as they are better for interpolation
	if (target_val.get_type() == Variant::INT) target_val = target_val.operator real_t();
	ERR_FAIL_COND_V(target_val.get_type() != p_initial_val.get_type(), false);

	// Make the new InterpolateData for the method follow
	InterpolateData data;
	data.active = true;
	data.type = FOLLOW_METHOD;
	data.finish = false;
	data.elapsed = 0;

	// Give the data it's configuration
	data.id = p_object->get_instance_id();
	data.key.push_back(p_method);
	data.concatenated_key = p_method;
	data.initial_val = p_initial_val;
	data.target_id = p_target->get_instance_id();
	data.target_key.push_back(p_target_method);
	data.duration = p_duration;
	data.trans_type = p_trans_type;
	data.ease_type = p_ease_type;
	data.delay = p_delay;

	// Add the new interpolation
	_push_interpolate_data(data);
	return true;
}

bool Tween::targeting_property(Object *p_object, NodePath p_property, Object *p_initial, NodePath p_initial_property, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
	// If we are currently updating, call this function again later
	if (pending_update != 0) {
		_add_pending_command(""targeting_property"", p_object, p_property, p_initial, p_initial_property, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
		return true;
	}
	// Grab the target property and the target property
	p_property = p_property.get_as_property_path();
	p_initial_property = p_initial_property.get_as_property_path();

	// Convert the initial INT values to REAL as they are better for Interpolation
	if (p_final_val.get_type() == Variant::INT) p_final_val = p_final_val.operator real_t();

	// Verify both objects are valid
	ERR_FAIL_COND_V(p_object == NULL, false);
	ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_object), false);
	ERR_FAIL_COND_V(p_initial == NULL, false);
	ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_initial), false);

	// No negative durations
	ERR_FAIL_COND_V(p_duration < 0, false);

	// Ensure transition and easing types are valid
	ERR_FAIL_COND_V(p_trans_type < 0 || p_trans_type >= TRANS_COUNT, false);
	ERR_FAIL_COND_V(p_ease_type < 0 || p_ease_type >= EASE_COUNT, false);

	// No negative delays
	ERR_FAIL_COND_V(p_delay < 0, false);

	// Ensure the initial and target properties exist on their objects
	bool prop_valid = false;
	p_object->get_indexed(p_property.get_subnames(), &prop_valid);
	ERR_FAIL_COND_V(!prop_valid, false);

	bool initial_prop_valid = false;
	Variant initial_val = p_initial->get_indexed(p_initial_property.get_subnames(), &initial_prop_valid);
	ERR_FAIL_COND_V(!initial_prop_valid, false);

	// Convert the initial INT value to REAL as it is better for interpolation
	if (initial_val.get_type() == Variant::INT) initial_val = initial_val.operator real_t();
	ERR_FAIL_COND_V(initial_val.get_type() != p_final_val.get_type(), false);

	// Build the InterpolateData object
	InterpolateData data;
	data.active = true;
	data.type = TARGETING_PROPERTY;
	data.finish = false;
	data.elapsed = 0;

	// Give the data it's configuration
	data.id = p_object->get_instance_id();
	data.key = p_property.get_subnames();
	data.concatenated_key = p_property.get_concatenated_subnames();
	data.target_id = p_initial->get_instance_id();
	data.target_key = p_initial_property.get_subnames();
	data.initial_val = initial_val;
	data.final_val = p_final_val;
	data.duration = p_duration;
	data.trans_type = p_trans_type;
	data.ease_type = p_ease_type;
	data.delay = p_delay;

	// Ensure there is a valid delta
	if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val))
		return false;

	// Add the interpolation
	_push_interpolate_data(data);
	return true;
}

bool Tween::targeting_method(Object *p_object, StringName p_method, Object *p_initial, StringName p_initial_method, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) {
	// If we are currently updating, call this function again later
	if (pending_update != 0) {
		_add_pending_command(""targeting_method"", p_object, p_method, p_initial, p_initial_method, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
		return true;
	}

	// Convert final INT values to REAL as they are better for interpolation
	if (p_final_val.get_type() == Variant::INT) p_final_val = p_final_val.operator real_t();

	// Make sure the given objects are valid
	ERR_FAIL_COND_V(p_object == NULL, false);
	ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_object), false);
	ERR_FAIL_COND_V(p_initial == NULL, false);
	ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_initial), false);

	// No negative durations
	ERR_FAIL_COND_V(p_duration < 0, false);

	// Ensure transition and easing types are valid
	ERR_FAIL_COND_V(p_trans_type < 0 || p_trans_type >= TRANS_COUNT, false);
	ERR_FAIL_COND_V(p_ease_type < 0 || p_ease_type >= EASE_COUNT, false);

	// No negative delays
	ERR_FAIL_COND_V(p_delay < 0, false);

	// Make sure both objects have the given method
	ERR_FAIL_COND_V_MSG(!p_object->has_method(p_method), false, ""Object has no method named: "" + p_method + ""."");
	ERR_FAIL_COND_V_MSG(!p_initial->has_method(p_initial_method), false, ""Initial Object has no method named: "" + p_initial_method + ""."");

	// Call the method to get the initial value
	Variant::CallError error;
	Variant initial_val = p_initial->call(p_initial_method, NULL, 0, error);
	ERR_FAIL_COND_V(error.error != Variant::CallError::CALL_OK, false);

	// Convert initial INT values to REAL as they aer better for interpolation
	if (initial_val.get_type() == Variant::INT) initial_val = initial_val.operator real_t();
	ERR_FAIL_COND_V(initial_val.get_type() != p_final_val.get_type(), false);

	// Build the new InterpolateData object
	InterpolateData data;
	data.active = true;
	data.type = TARGETING_METHOD;
	data.finish = false;
	data.elapsed = 0;

	// Configure the data
	data.id = p_object->get_instance_id();
	data.key.push_back(p_method);
	data.concatenated_key = p_method;
	data.target_id = p_initial->get_instance_id();
	data.target_key.push_back(p_initial_method);
	data.initial_val = initial_val;
	data.final_val = p_final_val;
	data.duration = p_duration;
	data.trans_type = p_trans_type;
	data.ease_type = p_ease_type;
	data.delay = p_delay;

	// Ensure there is a valid delta
	if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val))
		return false;

	// Add the interpolation
	_push_interpolate_data(data);
	return true;
}

Tween::Tween() {
	// Initialize tween attributes
	tween_process_mode = TWEEN_PROCESS_IDLE;
	repeat = false;
	speed_scale = 1;
	pending_update = 0;
	uid = 0;
}

Tween::~Tween() {
}
",16311,True,2886.8608695506887,median
"/*
 * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
 */

#include <boost/bind.hpp>
#include <boost/assign/list_of.hpp>
#include <boost/pointer_cast.hpp>

#include ""analytics/diffstats.h""
#include <base/parse_object.h>
#include <sandesh/sandesh_constants.h>
#include <sandesh/sandesh_types.h>
#include <sandesh/sandesh.h>

#include ""cdb_if.h""

using namespace ::apache::thrift;
using namespace ::apache::thrift::protocol;
using namespace ::apache::thrift::transport;
using namespace ::org::apache::cassandra;
namespace cassandra = ::org::apache::cassandra;
using namespace GenDb;

#define CDBIF_LOG_ERR_RETURN_FALSE(_Msg)                                  \\
    do {                                                                  \\
        LOG(ERROR, name_ << "": "" << __func__ << "":"" << __FILE__ << "":"" << \\
            __LINE__ << "": "" << _Msg);                                    \\
        return false;                                                     \\
    } while (false)    

#define CDBIF_LOG(_Level, _Msg)                                           \\
    do {                                                                  \\
        if (LoggingDisabled()) break;                                     \\
        log4cplus::Logger logger = log4cplus::Logger::getRoot();          \\
        LOG4CPLUS_##_Level(logger, name_ << "": "" << __func__ << "":"" <<    \\
            __FILE__ << "":"" << __LINE__ << "": "" << _Msg);                 \\
    } while (false)

#define CDBIF_LOG_ERR(_Msg)                                               \\
    do {                                                                  \\
        LOG(ERROR, name_ << "": "" << __func__ << "":"" << __FILE__ << "":"" << \\
            __LINE__ << "": "" << _Msg);                                    \\
    } while (false)

#define CDBIF_LOG_ERR_STATIC(_Msg)                                        \\
    do {                                                                  \\
        LOG(ERROR, __func__ << "":"" << __FILE__ << "":"" << __LINE__ << "": "" \\
            << _Msg);                                                     \\
    } while (false)

#define CDBIF_EXPECT_TRUE_ELSE_RETURN_FALSE(cond)                         \\
    do {                                                                  \\
        if (!(cond)) {                                                    \\
            LOG(ERROR, name_ << "": "" << __func__ << "":"" << __FILE__ <<    \\
                "":"" << __LINE__ << "": ("" << #cond << "") FALSE"");          \\
            return false;                                                 \\
        }                                                                 \\
    } while (false)

#define CDBIF_EXPECT_TRUE(cond)                                           \\
    do {                                                                  \\
        if (!(cond)) {                                                    \\
            LOG(ERROR, name_ << "": "" << __func__ << "":"" << __FILE__ <<    \\
                "":"" << __LINE__ << "": ("" << #cond << "") FALSE"");          \\
        }                                                                 \\
    } while (false)

#define CDBIF_BEGIN_TRY try
#define CDBIF_END_TRY_LOG_INTERNAL(msg, ignore_eexist, no_log_not_found,   \\
    invoke_hdlr, err_type, cf_op)                                          \\
    catch (NotFoundException &tx) {                                        \\
        stats_.IncrementErrors(err_type);                                  \\
        UpdateCfStats(cf_op, msg);                                         \\
        std::ostringstream ostr;                                           \\
        ostr << msg << "": NotFoundException: "" << tx.what();               \\
        if (!(no_log_not_found)) {                                         \\
            CDBIF_LOG_ERR(ostr.str());                                     \\
        }                                                                  \\
    } catch (SchemaDisagreementException &tx) {                            \\
        stats_.IncrementErrors(err_type);                                  \\
        UpdateCfStats(cf_op, msg);                                         \\
        std::ostringstream ostr;                                           \\
        ostr << msg << "": SchemaDisagreementException: "" << tx.what();     \\
        CDBIF_LOG_ERR(ostr.str());                                         \\
    } catch (InvalidRequestException &tx) {                                \\
        if (ignore_eexist) {                                               \\
            size_t eexist = tx.why.find(                                   \\
                ""Cannot add already existing column family"");              \\
            if (eexist == std::string::npos) {                             \\
                stats_.IncrementErrors(err_type);                          \\
                UpdateCfStats(cf_op, msg);                                 \\
                std::ostringstream ostr;                                   \\
                ostr << msg << "": InvalidRequestException: "" << tx.why;    \\
                CDBIF_LOG_ERR(ostr.str());                                 \\
            }                                                              \\
        } else {                                                           \\
            stats_.IncrementErrors(err_type);                              \\
            UpdateCfStats(cf_op, msg);                                     \\
            std::ostringstream ostr;                                       \\
            ostr << msg << "": InvalidRequestException: "" << tx.why;        \\
            CDBIF_LOG_ERR(ostr.str());                                     \\
        }                                                                  \\
    } catch (UnavailableException& ue) {                                   \\
        stats_.IncrementErrors(err_type);                                  \\
        UpdateCfStats(cf_op, msg);                                         \\
        std::ostringstream ostr;                                           \\
        ostr << msg << "": UnavailableException: "" << ue.what();            \\
        CDBIF_LOG_ERR(ostr.str());                                         \\
    } catch (TimedOutException& te) {                                      \\
        stats_.IncrementErrors(err_type);                                  \\
        UpdateCfStats(cf_op, msg);                                         \\
        std::ostringstream ostr;                                           \\
        ostr << msg << "": TimedOutException: "" << te.what();               \\
        CDBIF_LOG_ERR(ostr.str());                                         \\
    } catch (TApplicationException &tx) {                                  \\
        stats_.IncrementErrors(err_type);                                  \\
        UpdateCfStats(cf_op, msg);                                         \\
        std::ostringstream ostr;                                           \\
        ostr << msg << "": TApplicationException: "" << tx.what();           \\
        CDBIF_LOG_ERR(ostr.str());                                         \\
    } catch (TTransportException &tx) {                                    \\
        stats_.IncrementErrors(err_type);                                  \\
        UpdateCfStats(cf_op, msg);                                         \\
        if ((invoke_hdlr)) {                                               \\
            errhandler_();                                                 \\
        }                                                                  \\
        std::ostringstream ostr;                                           \\
        ostr << msg << "": TTransportException: "" << tx.what();             \\
        CDBIF_LOG_ERR(ostr.str());                                         \\
    } catch (TException &tx) {                                             \\
        stats_.IncrementErrors(err_type);                                  \\
        UpdateCfStats(cf_op, msg);                                         \\
        std::ostringstream ostr;                                           \\
        ostr << msg << "": TException: "" << tx.what();                      \\
        CDBIF_LOG_ERR(ostr.str());                                         \\
    }

#define CDBIF_END_TRY_RETURN_FALSE_INTERNAL(msg, ignore_eexist,            \\
    no_log_not_found, invoke_hdlr, err_type, cf_op)                        \\
    catch (NotFoundException &tx) {                                        \\
        stats_.IncrementErrors(err_type);                                  \\
        UpdateCfStats(cf_op, msg);                                         \\
        std::ostringstream ostr;                                           \\
        ostr << msg << "": NotFoundException: "" << tx.what();               \\
        if (!(no_log_not_found)) {                                         \\
            CDBIF_LOG_ERR_RETURN_FALSE(ostr.str());                        \\
        } else {                                                           \\
            return false;                                                  \\
        }                                                                  \\
    } catch (SchemaDisagreementException &tx) {                            \\
        stats_.IncrementErrors(err_type);                                  \\
        UpdateCfStats(cf_op, msg);                                         \\
        std::ostringstream ostr;                                           \\
        ostr << msg << "": SchemaDisagreementException: "" << tx.what();     \\
        CDBIF_LOG_ERR_RETURN_FALSE(ostr.str());                            \\
    } catch (InvalidRequestException &tx) {                                \\
        if (ignore_eexist) {                                               \\
            size_t eexist = tx.why.find(                                   \\
                ""Cannot add already existing column family"");              \\
            if (eexist == std::string::npos) {                             \\
                stats_.IncrementErrors(err_type);                          \\
                UpdateCfStats(cf_op, msg);                                 \\
                std::ostringstream ostr;                                   \\
                ostr << msg << "": InvalidRequestException: "" << tx.why;    \\
                CDBIF_LOG_ERR_RETURN_FALSE(ostr.str());                    \\
            }                                                              \\
        } else {                                                           \\
            stats_.IncrementErrors(err_type);                              \\
            UpdateCfStats(cf_op, msg);                                     \\
            std::ostringstream ostr;                                       \\
            ostr << msg << "": InvalidRequestException: "" << tx.why;        \\
            CDBIF_LOG_ERR_RETURN_FALSE(ostr.str());                        \\
        }                                                                  \\
    } catch (UnavailableException& ue) {                                   \\
        stats_.IncrementErrors(err_type);                                  \\
        UpdateCfStats(cf_op, msg);                                         \\
        std::ostringstream ostr;                                           \\
        ostr << msg << "": UnavailableException: "" << ue.what();            \\
        CDBIF_LOG_ERR_RETURN_FALSE(ostr.str());                            \\
    } catch (TimedOutException& te) {                                      \\
        stats_.IncrementErrors(err_type);                                  \\
        UpdateCfStats(cf_op, msg);                                         \\
        std::ostringstream ostr;                                           \\
        ostr << msg << "": TimedOutException: "" << te.what();               \\
        CDBIF_LOG_ERR_RETURN_FALSE(ostr.str());                            \\
    } catch (TApplicationException &tx) {                                  \\
        stats_.IncrementErrors(err_type);                                  \\
        UpdateCfStats(cf_op, msg);                                         \\
        std::ostringstream ostr;                                           \\
        ostr << msg << "": TApplicationException: "" << tx.what();           \\
        CDBIF_LOG_ERR_RETURN_FALSE(ostr.str());                            \\
    } catch (TTransportException &tx) {                                    \\
        stats_.IncrementErrors(err_type);                                  \\
        UpdateCfStats(cf_op, msg);                                         \\
        if ((invoke_hdlr)) {                                               \\
            errhandler_();                                                 \\
        }                                                                  \\
        std::ostringstream ostr;                                           \\
        ostr << msg << "": TTransportException: "" << tx.what();             \\
        CDBIF_LOG_ERR_RETURN_FALSE(ostr.str());                            \\
    } catch (TException &tx) {                                             \\
        stats_.IncrementErrors(err_type);                                  \\
        UpdateCfStats(cf_op, msg);                                         \\
        std::ostringstream ostr;                                           \\
        ostr << msg << "": TException: "" << tx.what();                      \\
        CDBIF_LOG_ERR_RETURN_FALSE(ostr.str());                            \\
    }

#define CDBIF_END_TRY_RETURN_FALSE(msg)                                    \\
    CDBIF_END_TRY_RETURN_FALSE_INTERNAL(msg, false, false, false,          \\
        CdbIfStats::CDBIF_STATS_ERR_NO_ERROR,                              \\
        CdbIfStats::CDBIF_STATS_CF_OP_NONE)

#define CDBIF_END_TRY_LOG(msg)                                             \\
    CDBIF_END_TRY_LOG_INTERNAL(msg, false, false, false,                   \\
        CdbIfStats::CDBIF_STATS_ERR_NO_ERROR,                              \\
        CdbIfStats::CDBIF_STATS_CF_OP_NONE)

//
// Types supported by Cassandra are the following, but we use only a subset for
// now
//    AsciiType = 1,
//    LongType = 2,
//    BytesType = 3,
//    BooleanType = 4,
//    CounterColumnType = 5,
//    DecimalType = 6,
//    DoubleType = 7,
//    FloatType = 8,
//    Int32Type = 9,
//    UTF8Type = 10,
//    DateType = 11,
//    LexicalUUIDType = 12,
//    IntegerType = 13,
//    TimeUUIDType = 14,
//    CompositeType = 15,
//

//
// Composite Encoding and Decoding
//

// String
std::string DbEncodeStringComposite(const GenDb::DbDataValue &value) {
    std::string input;
    try {
        input = boost::get<std::string>(value);
    } catch (boost::bad_get &ex) {
        CDBIF_LOG_ERR_STATIC(""Extract type "" << value.which() << "" FAILED: "" <<
            ex.what());
    }
    int input_size = input.size();
    uint8_t *data = (uint8_t *)malloc(input_size+3);
    if (data == NULL) {
        CDBIF_LOG_ERR_STATIC(""Allocation (size="" << (input_size+3) <<
            "") FAILED"");
        return """";
    }
    int i = 0;
    put_value(data+i, 2, input_size);
    i += 2;
    memcpy(&data[i], input.c_str(), input_size);
    i += input_size;
    data[i++] = '\\0';
    std::string output((const char *)data, i);
    free(data);
    return output;
}

GenDb::DbDataValue DbDecodeStringComposite(const char *input,
    int &used) {
    used = 0;
    uint16_t len = get_value((const uint8_t *)input, 2);
    used += 2;
    std::string output(&input[used], len);
    used += len;
    used++; // skip eoc
    return output;
}

// UUID
std::string DbEncodeUUIDComposite(const GenDb::DbDataValue &value) {
    boost::uuids::uuid u;
    try {
        u = boost::get<boost::uuids::uuid>(value);
    } catch (boost::bad_get &ex) {
        CDBIF_LOG_ERR_STATIC(""Extract type "" << value.which() << "" FAILED: "" <<
            ex.what());
    }
    uint8_t data[32];
    int i = 0;
    put_value(data+i, 2, 0x0010);
    i += 2;
    std::string u_s(u.size(), 0);
    std::copy(u.begin(), u.end(), u_s.begin());
    memcpy(data+i, u_s.c_str(), u_s.size());
    i += 16;
    data[i++] = '\\0';
    std::string output((const char *)data, i);
    return output;
}

GenDb::DbDataValue DbDecodeUUIDComposite(const char *input, int &used) {
    boost::uuids::uuid u;
    used = 0;
    uint16_t len = get_value((const uint8_t *)input, 2);
    assert(len == 0x0010);
    used += 2;
    memcpy(&u, input+used, 0x0010);
    used += 0x0010;
    used++;
    return u;
}

// Double
std::string DbEncodeDoubleComposite(const GenDb::DbDataValue &value) {
    uint8_t data[16];
    double input = 0;
    try {
        input = boost::get<double>(value);
    } catch (boost::bad_get &ex) {
        CDBIF_LOG_ERR_STATIC(""Extract type "" << value.which() << "" FAILED: "" <<
            ex.what());
    }
    int size = sizeof(double);
    int i = 0;
    put_value(data+i, 2, size);
    i += 2;
    put_double(data+i, input);
    i += size;
    data[i++] = '\\0';
    std::string output((const char *)data, i);
    return output;
}

GenDb::DbDataValue DbDecodeDoubleComposite(const char *input,
    int &used) {
    used = 0;
    // skip len
    used += 2;
    double output = get_double((const uint8_t *)&input[used]);
    used += sizeof(double);
    used++; // skip eoc
    return output;
}

// Integer
std::string DbEncodeIntegerCompositeInternal(uint64_t input) {
    uint8_t data[16];
    int size = 1;
    uint64_t temp_input = input >> 8;
    if (input < 256) {
        if (input > 127) size++;
    }
    while (temp_input) {
        if (temp_input < 256) {
            if (temp_input > 127) {
                size++; //additional byte to take care of unsigned-ness
            }
        }
        temp_input >>= 8;
        size++;
    }
    int i = 0;
    put_value(data+i, 2, size);
    i += 2;
    put_value(data+i, size, input);
    i += size;
    data[i++] = '\\0';
    std::string output((const char *)data, i);
    return output;
}

template <typename T>
std::string DbEncodeIntegerComposite(const GenDb::DbDataValue &value) {
    uint64_t input(std::numeric_limits<T>::max());
    try {
        input = boost::get<T>(value);
    } catch (boost::bad_get &ex) {
        CDBIF_LOG_ERR_STATIC(""Extract type "" << value.which() << "" FAILED: "" <<
            ex.what());
    }
    return DbEncodeIntegerCompositeInternal(input);
}

template <typename T>
GenDb::DbDataValue DbDecodeIntegerComposite(const char *input,
    int &used) {
    used = 0;
    uint16_t len = get_value((const uint8_t *)input, 2);
    used += 2;
    T output = 0;
    for (int i = 0; i < len; i++) {
        output = (output << 8) | (uint8_t)input[used++];
    }
    used++; // skip eoc
    return output;
}

//
// Non Composite Encoding and Decoding
//

// String
std::string DbEncodeStringNonComposite(const GenDb::DbDataValue &value) {
    std::string output;
    try {
        output = boost::get<std::string>(value);
    } catch (boost::bad_get &ex) {
        CDBIF_LOG_ERR_STATIC(""Extract type "" << value.which() << "" FAILED: "" <<
            ex.what());
    }
    return output;
}

GenDb::DbDataValue DbDecodeStringNonComposite(const std::string &input) {
    return input;
}

// UUID
std::string DbEncodeUUIDNonComposite(const GenDb::DbDataValue &value) {
    boost::uuids::uuid u;
    try {
        u = boost::get<boost::uuids::uuid>(value);
    } catch (boost::bad_get &ex) {
        CDBIF_LOG_ERR_STATIC(""Extract type "" << value.which() << "" FAILED: "" <<
            ex.what());
    }
    std::string u_s(u.size(), 0);
    std::copy(u.begin(), u.end(), u_s.begin());
    return u_s;
}

GenDb::DbDataValue DbDecodeUUIDNonComposite(const std::string &input) {
    boost::uuids::uuid u;
    memcpy(&u, input.c_str(), 0x0010);
    return u;
}

// Double
std::string DbEncodeDoubleNonComposite(const GenDb::DbDataValue &value) {
    double temp = 0;
    try {
        temp = boost::get<double>(value);
    } catch (boost::bad_get &ex) {
        CDBIF_LOG_ERR_STATIC(""Extract type "" << value.which() << "" FAILED: "" <<
            ex.what());
    }
    uint8_t data[16];
    put_double(data, temp);
    std::string output((const char *)data, sizeof(double));
    return output;
}

GenDb::DbDataValue DbDecodeDoubleNonComposite(const std::string &input) {
    double output(get_double((const uint8_t *)(input.c_str())));
    return output;
}

// Integer
template <typename T>
std::string DbEncodeIntegerNonComposite(
    const GenDb::DbDataValue &value) {
    T temp(std::numeric_limits<T>::max());
    try {
        temp = boost::get<T>(value);
    } catch (boost::bad_get &ex) {
        CDBIF_LOG_ERR_STATIC(""Extract type "" << value.which() << "" FAILED: "" <<
            ex.what());
    }
    uint8_t data[16];
    int size = 1;
    T temp1 = temp >> 8;
    if (temp < 256) {
        if (temp > 127) size++;
    }
    while (temp1) {
        if (temp1 < 256) {
            if (temp1 > 127) size++;
        }
        temp1 >>= 8;
        size++;
    }
    put_value(data, size, temp);
    std::string output((const char *)data, size);
    return output;
}

template <typename T>
GenDb::DbDataValue DbDecodeIntegerNonComposite(
    const std::string &input) {
    uint64_t output = get_value_unaligned((const uint8_t *)(input.c_str()),
        input.size());
    return ((T)output);
}

CdbIf::CdbIfTypeMapDef CdbIf::CdbIfTypeMap =
    boost::assign::map_list_of
        (GenDb::DbDataType::AsciiType, 
             CdbIf::CdbIfTypeInfo(""AsciiType"",
                 DbEncodeStringComposite, 
                 DbDecodeStringComposite,
                 DbEncodeStringNonComposite,
                 DbDecodeStringNonComposite))
        (GenDb::DbDataType::LexicalUUIDType,
            CdbIf::CdbIfTypeInfo(""LexicalUUIDType"",
                DbEncodeUUIDComposite,
                DbDecodeUUIDComposite,
                DbEncodeUUIDNonComposite,
                DbDecodeUUIDNonComposite))
        (GenDb::DbDataType::TimeUUIDType,
            CdbIf::CdbIfTypeInfo(""TimeUUIDType"",
                DbEncodeUUIDComposite,
                DbDecodeUUIDComposite,
                DbEncodeUUIDNonComposite,
                DbDecodeUUIDNonComposite))
        (GenDb::DbDataType::Unsigned8Type,
            CdbIf::CdbIfTypeInfo(""IntegerType"",
                DbEncodeIntegerComposite<uint8_t>,
                DbDecodeIntegerComposite<uint8_t>,
                DbEncodeIntegerNonComposite<uint8_t>,
                DbDecodeIntegerNonComposite<uint8_t>))
        (GenDb::DbDataType::Unsigned16Type,
            CdbIf::CdbIfTypeInfo(""IntegerType"",
                DbEncodeIntegerComposite<uint16_t>,
                DbDecodeIntegerComposite<uint16_t>,
                DbEncodeIntegerNonComposite<uint16_t>,
                DbDecodeIntegerNonComposite<uint16_t>))
        (GenDb::DbDataType::Unsigned32Type,
            CdbIf::CdbIfTypeInfo(""IntegerType"",
                DbEncodeIntegerComposite<uint32_t>,
                DbDecodeIntegerComposite<uint32_t>,
                DbEncodeIntegerNonComposite<uint32_t>,
                DbDecodeIntegerNonComposite<uint32_t>))
        (GenDb::DbDataType::Unsigned64Type,
            CdbIf::CdbIfTypeInfo(""IntegerType"",
                DbEncodeIntegerComposite<uint64_t>,
                DbDecodeIntegerComposite<uint64_t>,
                DbEncodeIntegerNonComposite<uint64_t>,
                DbDecodeIntegerNonComposite<uint64_t>))
        (GenDb::DbDataType::DoubleType,
            CdbIf::CdbIfTypeInfo(""DoubleType"",
                DbEncodeDoubleComposite,
                DbDecodeDoubleComposite,
                DbEncodeDoubleNonComposite,
                DbDecodeDoubleNonComposite));

class CdbIf::CleanupTask : public Task {
public:
    CleanupTask(std::string task_id, int task_instance, CdbIf *cdbif) :
        Task(TaskScheduler::GetInstance()->GetTaskId(task_id),
             task_instance),
        cdbif_(cdbif) {
    }

    virtual bool Run() {
        tbb::mutex::scoped_lock lock(cdbif_->cdbq_mutex_);
        // Return if cleanup was cancelled
        if (cdbif_->cleanup_task_ == NULL) {
            return true;
        }
        if (cdbif_->cdbq_.get() != NULL) {
            cdbif_->cdbq_->Shutdown();
            cdbif_->cdbq_.reset();
        }
        cdbif_->cleanup_task_ = NULL;
        return true;
    }

private:
    CdbIf *cdbif_;
};

class CdbIf::InitTask : public Task {
public:
    InitTask(std::string task_id, int task_instance, CdbIf *cdbif) :
        Task(TaskScheduler::GetInstance()->GetTaskId(task_id),
             task_instance),
        task_id_(task_id),
        task_instance_(task_instance),
        cdbif_(cdbif) {
    }

    virtual bool Run() {
        tbb::mutex::scoped_lock lock(cdbif_->cdbq_mutex_);
        if (cdbif_->cdbq_.get() != NULL) {
            cdbif_->cdbq_->Shutdown();
        }
        TaskScheduler *scheduler = TaskScheduler::GetInstance();
        cdbif_->cdbq_.reset(new CdbIfQueue(
            scheduler->GetTaskId(task_id_), cdbif_->task_instance_,
            boost::bind(&CdbIf::Db_AsyncAddColumn, cdbif_, _1)));
        cdbif_->cdbq_->SetStartRunnerFunc(
            boost::bind(&CdbIf::Db_IsInitDone, cdbif_));
        cdbif_->cdbq_->SetExitCallback(boost::bind(&CdbIf::Db_BatchAddColumn,
            cdbif_, _1));
        cdbif_->Db_SetQueueWaterMarkInternal(cdbif_->cdbq_.get(),
            cdbif_->cdbq_wm_info_);
        if (cdbif_->cleanup_task_) {
            scheduler->Cancel(cdbif_->cleanup_task_);
            cdbif_->cleanup_task_ = NULL;
        }
        cdbif_->init_task_ = NULL;
        return true;
    }

private:
    std::string task_id_;
    int task_instance_;
    CdbIf *cdbif_;
};

CdbIf::CdbIf(DbErrorHandler errhandler,
        const std::vector<std::string> &cassandra_ips,
        const std::vector<int> &cassandra_ports, int ttl,
        std::string name, bool only_sync) :
    socket_(new TSocketPool(cassandra_ips, cassandra_ports)),
    transport_(new TFramedTransport(socket_)),
    protocol_(new TBinaryProtocol(transport_)),
    client_(new CassandraClient(protocol_)),
    errhandler_(errhandler),
    name_(name),
    init_task_(NULL),
    cleanup_task_(NULL),
    cassandra_ttl_(ttl),
    only_sync_(only_sync),
    task_instance_(-1),
    prev_task_instance_(-1),
    task_instance_initialized_(false) {

    // reduce connection timeout
    boost::shared_ptr<TSocket> tsocket = 
        boost::dynamic_pointer_cast<TSocket>(socket_);
    tsocket->setConnTimeout(connectionTimeout);

    db_init_done_ = false;
}

CdbIf::CdbIf() : 
    init_task_(NULL), 
    cleanup_task_(NULL),
    cassandra_ttl_(-1), 
    only_sync_(false), 
    task_instance_(-1),
    prev_task_instance_(-1),
    task_instance_initialized_(false) {
    db_init_done_ = false;
}

CdbIf::~CdbIf() {
    tbb::mutex::scoped_lock lock(cdbq_mutex_);
    if (transport_) {
        transport_->close();
    }
    TaskScheduler *scheduler = TaskScheduler::GetInstance();
    if (init_task_) {
        scheduler->Cancel(init_task_);
        init_task_ = NULL;
    }
    if (cleanup_task_) {
        scheduler->Cancel(cleanup_task_);
        cleanup_task_ = NULL;
    }
}

bool CdbIf::Db_IsInitDone() const {
    return db_init_done_;
}

void CdbIf::Db_SetInitDone(bool init_done) {
    db_init_done_ = init_done;
}

bool CdbIf::Db_Init(const std::string& task_id, int task_instance) {
    std::ostringstream ostr;
    ostr << task_id << "":"" << task_instance;
    std::string errstr(ostr.str());
    CDBIF_BEGIN_TRY {
        transport_->open();
    } CDBIF_END_TRY_RETURN_FALSE(errstr)
    if (only_sync_) {
        return true;
    }
    tbb::mutex::scoped_lock lock(cdbq_mutex_);
    // Initialize task instance
    if (!task_instance_initialized_) {
        task_instance_ = task_instance;
        task_instance_initialized_ = true;
    }
    if (!init_task_) {
        // Start init task with previous task instance to ensure
        // task exclusion with dequeue and exit callback task
        // when calling shutdown
        prev_task_instance_ = task_instance_;
        task_instance_ = task_instance;
        init_task_ = new InitTask(task_id, prev_task_instance_, this);
        TaskScheduler *scheduler = TaskScheduler::GetInstance();
        scheduler->Enqueue(init_task_);
        CDBIF_LOG(INFO, ""Initialization Task Created: "" <<
            prev_task_instance_ << "" -> "" << task_instance_);
    } else {
        prev_task_instance_ = task_instance_;
        task_instance_ = task_instance;
        CDBIF_LOG(INFO, ""Initialization Task Present: "" <<
            prev_task_instance_ << "" -> "" << task_instance_);
    }
    return true;
}

void CdbIf::Db_UninitUnlocked(const std::string& task_id, int task_instance) {
    std::ostringstream ostr;
    ostr << task_id << "":"" << task_instance;
    std::string errstr(ostr.str());
    CDBIF_BEGIN_TRY {
        transport_->close();
    } CDBIF_END_TRY_LOG(errstr)
    if (only_sync_) {
        return;
    }
    if (!cleanup_task_) {
        cleanup_task_ = new CleanupTask(task_id, task_instance, this);
        TaskScheduler *scheduler = TaskScheduler::GetInstance();
        scheduler->Enqueue(cleanup_task_);
    }
}

void CdbIf::Db_Uninit(const std::string& task_id, int task_instance) {
    tbb::mutex::scoped_lock lock(cdbq_mutex_);
    Db_UninitUnlocked(task_id, task_instance);
}

std::string CdbIf::Db_GetHost() const {
    boost::shared_ptr<TSocket> tsocket = 
        boost::dynamic_pointer_cast<TSocket>(socket_);
    return tsocket->getHost();
}

int CdbIf::Db_GetPort() const {
    boost::shared_ptr<TSocket> tsocket = 
        boost::dynamic_pointer_cast<TSocket>(socket_);
    return tsocket->getPort();
}

void CdbIf::Db_SetQueueWaterMarkInternal(CdbIfQueue *queue,
    DbQueueWaterMarkInfo &wmi) {
    CdbIfQueue::WaterMarkInfo wm(wmi.get<1>(), wmi.get<2>());
    if (wmi.get<0>()) {
        queue->SetHighWaterMark(wm);
    } else {
        queue->SetLowWaterMark(wm);
    }
}

void CdbIf::Db_SetQueueWaterMarkInternal(CdbIfQueue *queue,
    std::vector<DbQueueWaterMarkInfo> &vwmi) {
    for (std::vector<DbQueueWaterMarkInfo>::iterator it =
         vwmi.begin(); it != vwmi.end(); it++) {
        Db_SetQueueWaterMarkInternal(queue, *it);
    }
}

void CdbIf::Db_SetQueueWaterMark(bool high, size_t queue_count,
                                 DbQueueWaterMarkCb cb) {
    DbQueueWaterMarkInfo wm(high, queue_count, cb);
    cdbq_wm_info_.push_back(wm);
    tbb::mutex::scoped_lock lock(cdbq_mutex_);
    if (cdbq_.get() == NULL) {
        return;
    }
    Db_SetQueueWaterMarkInternal(cdbq_.get(), wm);
}

void CdbIf::Db_ResetQueueWaterMarks() {
    cdbq_wm_info_.clear();
    tbb::mutex::scoped_lock lock(cdbq_mutex_);
    if (cdbq_.get() != NULL) {
        cdbq_->ResetHighWaterMark();
        cdbq_->ResetLowWaterMark();
    }
}

bool CdbIf::Db_AddTablespace(const std::string& tablespace,
    const std::string& replication_factor) {
    if (!Db_FindTablespace(tablespace)) {
        KsDef ks_def;
        ks_def.__set_name(tablespace);
        ks_def.__set_strategy_class(""SimpleStrategy"");
        std::map<std::string, std::string> strat_options;
        strat_options.insert(std::pair<std::string,
            std::string>(""replication_factor"", replication_factor));
        ks_def.__set_strategy_options(strat_options);

        CDBIF_BEGIN_TRY {
            std::string retval;
            client_->system_add_keyspace(retval, ks_def);
        } CDBIF_END_TRY_RETURN_FALSE(tablespace)

        return true;
    }
    return true;
}

bool CdbIf::Db_SetTablespace(const std::string& tablespace) {
    if (!Db_FindTablespace(tablespace)) {
        CDBIF_LOG_ERR_RETURN_FALSE(""Tablespace: "" << tablespace << 
            ""NOT FOUND"");
    }
    CDBIF_BEGIN_TRY {
        client_->set_keyspace(tablespace);
        tablespace_ = tablespace;
    } CDBIF_END_TRY_RETURN_FALSE(tablespace)

    KsDef retval;
    CDBIF_BEGIN_TRY {
        client_->describe_keyspace(retval, tablespace);
    } CDBIF_END_TRY_RETURN_FALSE(tablespace)

    std::vector<CfDef>::const_iterator iter;
    for (iter = retval.cf_defs.begin(); iter != retval.cf_defs.end(); iter++) {
        std::string name = (*iter).name;
        CfDef *cfdef = new CfDef;
        *cfdef = *iter;
        CdbIfCfList.insert(name, new CdbIfCfInfo(cfdef));
    }
    return true;
}

bool CdbIf::Db_AddSetTablespace(const std::string& tablespace,
    const std::string& replication_factor) {
    if (!Db_AddTablespace(tablespace, replication_factor)) {
        stats_.IncrementErrors(
            CdbIfStats::CDBIF_STATS_ERR_WRITE_TABLESPACE);
        return false;
    }
    if (!Db_SetTablespace(tablespace)) {
        stats_.IncrementErrors(
            CdbIfStats::CDBIF_STATS_ERR_READ_TABLESPACE);
        return false;
    }
    return true;
}

bool CdbIf::Db_FindTablespace(const std::string& tablespace) {
    CDBIF_BEGIN_TRY {
        KsDef retval;
        client_->describe_keyspace(retval, tablespace);
    } CDBIF_END_TRY_RETURN_FALSE_INTERNAL(tablespace, false, true, false,
        CdbIfStats::CDBIF_STATS_ERR_NO_ERROR,
        CdbIfStats::CDBIF_STATS_CF_OP_NONE)
    return true;
}

bool CdbIf::Db_GetColumnfamily(CdbIfCfInfo **info, const std::string& cfname) {
    CdbIfCfListType::iterator it;
    if ((it = CdbIfCfList.find(cfname)) != CdbIfCfList.end()) {
        *info = it->second;
        return true;
    }
    return false;
}

bool CdbIf::Db_UseColumnfamily(const GenDb::NewCf& cf) {
    if (Db_FindColumnfamily(cf.cfname_)) {
        return true;
    }
    CdbIfCfInfo *cfinfo;
    if (!Db_GetColumnfamily(&cfinfo, cf.cfname_)) {
        stats_.IncrementErrors(
            CdbIfStats::CDBIF_STATS_ERR_READ_COLUMN_FAMILY);
        UpdateCfReadFailStats(cf.cfname_);
        return false;
    }
    cfinfo->cf_.reset(new GenDb::NewCf(cf));
    return true;
}

bool CdbIf::Db_FindColumnfamily(const std::string& cfname) {
    CdbIfCfListType::iterator it;
    if ((it = CdbIfCfList.find(cfname)) != CdbIfCfList.end() &&
            (it->second->cf_.get())) {
        return true;
    }
    return false;
}

bool CdbIf::Db_Columnfamily_present(const std::string& cfname) {
    CdbIfCfListType::iterator it;
    if ((it = CdbIfCfList.find(cfname)) != CdbIfCfList.end()) {
        return true;
    }
    return false;
}

bool CdbIf::DbDataTypeVecToCompositeType(std::string& res,
    const GenDb::DbDataTypeVec& db_type) {
    if (db_type.size() == 0) {
        return false;
    } else if (db_type.size() == 1) {
        CdbIfTypeMapDef::iterator it;
        if ((it = CdbIfTypeMap.find(db_type.front())) == CdbIfTypeMap.end())
            return false;

        res = it->second.cassandra_type_;
        return true;
    } else {
        res = ""CompositeType("";
        std::vector<GenDb::DbDataType::type>::const_iterator it = db_type.begin();
        CdbIfTypeMapDef::iterator jt;

        if ((jt = CdbIfTypeMap.find(*it)) == CdbIfTypeMap.end())
            return false;
        res.append(jt->second.cassandra_type_);

        it++;
        for (; it != db_type.end(); it++) {
            res.append("", "");
            if ((jt = CdbIfTypeMap.find(*it)) == CdbIfTypeMap.end())
                return false;
            res.append(jt->second.cassandra_type_);
        }
        res.append("")"");
        return true;
    }
}

bool CdbIf::DbDataValueFromType(GenDb::DbDataValue& res,
    const GenDb::DbDataType::type& type, const std::string& input) {
    CdbIfTypeMapDef::iterator it = CdbIfTypeMap.find(type);

    if (it == CdbIfTypeMap.end()) {
        return false;
    }
    res = it->second.decode_non_composite_fn_(input);

    return true;
}

bool CdbIf::DbDataValueFromString(GenDb::DbDataValue& res,
    const std::string& cfname, const std::string& col_name,
    const std::string& input) {
    CdbIfCfInfo *info;
    GenDb::NewCf *cf;

    if (!Db_GetColumnfamily(&info, cfname) ||
            !((cf = info->cf_.get()))) {
        return false;
    }
    NewCf::SqlColumnMap::iterator it;
    if ((it = cf->cfcolumns_.find(col_name)) == cf->cfcolumns_.end()) {
        return false;
    }
    CdbIfTypeMapDef::iterator jt = CdbIfTypeMap.find(it->second);

    if (jt == CdbIfTypeMap.end()) {
        return false;
    }
    res = jt->second.decode_non_composite_fn_(input);

    return true;
}

bool CdbIf::DbDataValueToStringNonComposite(std::string& res,
        const GenDb::DbDataValue& value) {
    switch (value.which()) {
    case DB_VALUE_STRING:
        res = DbEncodeStringNonComposite(value);
        break;
    case DB_VALUE_UINT64:
        res = DbEncodeIntegerNonComposite<uint64_t>(value);
        break;
    case DB_VALUE_UINT32:
        res = DbEncodeIntegerNonComposite<uint32_t>(value);
        break;
    case DB_VALUE_UUID:
        res = DbEncodeUUIDNonComposite(value);
        break;
    case DB_VALUE_UINT8:
        res = DbEncodeIntegerNonComposite<uint8_t>(value);
        break;
    case DB_VALUE_UINT16:
        res = DbEncodeIntegerNonComposite<uint16_t>(value);
        break;
    case DB_VALUE_DOUBLE:
        res = DbEncodeDoubleNonComposite(value);
        break;
    case DB_VALUE_BLANK:
    default:
        assert(0);
        break;
    }
    return true;
};    

bool CdbIf::DbDataValueVecToString(std::string& res, bool composite,
        const GenDb::DbDataValueVec& input) {
    if (!composite) {
        if (input.size() == 1) {
            return DbDataValueToStringNonComposite(res, input[0]);
        }
    }
    // Composite encoding
    for (GenDb::DbDataValueVec::const_iterator it = input.begin();
         it != input.end(); it++) {
        const GenDb::DbDataValue &value(*it);
        switch (value.which()) {
        case DB_VALUE_STRING:
            res += DbEncodeStringComposite(value);
            break;
        case DB_VALUE_UINT64:
            res += DbEncodeIntegerComposite<uint64_t>(value);
            break;
        case DB_VALUE_UINT32:
            res += DbEncodeIntegerComposite<uint32_t>(value);
            break;
        case DB_VALUE_UUID:
            res += DbEncodeUUIDComposite(value);
            break;
        case DB_VALUE_UINT8:
            res += DbEncodeIntegerComposite<uint8_t>(value);
            break;
        case DB_VALUE_UINT16:
            res += DbEncodeIntegerComposite<uint16_t>(value);
            break;
        case DB_VALUE_DOUBLE:
            res += DbEncodeDoubleComposite(value);
            break;
        case DB_VALUE_BLANK:
        default:
            assert(0);
            break;
        }
    }    
    return true;
}

bool CdbIf::DbDataValueVecFromString(GenDb::DbDataValueVec& res,
        const GenDb::DbDataTypeVec& typevec,
        const std::string& input) {
    if (typevec.size() == 1) {
        GenDb::DbDataValue res1;
        if (!DbDataValueFromType(res1, typevec[0], input)) {
            CDBIF_LOG_ERR_RETURN_FALSE(""Extract type "" << typevec[0] 
                << "" from "" << input << "" FAILED"");
        }
        res.push_back(res1);
    } else {
        int used = 0;
        const int str_size = input.size();
        const char *data = input.c_str();
        for (GenDb::DbDataTypeVec::const_iterator it = typevec.begin();
                it != typevec.end(); it++) {
            const GenDb::DbDataType::type &type(*it);
            CdbIfTypeMapDef::iterator jt = CdbIfTypeMap.find(type);
            if (jt == CdbIfTypeMap.end()) {
                CDBIF_LOG_ERR(""Unknown type "" << type);
                continue;
            }
            int elem_use;
            CDBIF_EXPECT_TRUE_ELSE_RETURN_FALSE(used < str_size);
            GenDb::DbDataValue val(jt->second.decode_composite_fn_(data+used,
                elem_use));
            used += elem_use;
            res.push_back(val);
        }
    }
    return true;
}

bool CdbIf::ConstructDbDataValueKey(std::string& res, const GenDb::NewCf *cf,
    const GenDb::DbDataValueVec& rowkey) {
    bool composite = cf->key_validation_class.size() == 1 ? false : true;
    return DbDataValueVecToString(res, composite, rowkey);
}

bool CdbIf::ConstructDbDataValueColumnName(std::string& res,
    const GenDb::NewCf *cf, const GenDb::DbDataValueVec& name) {
    bool composite = cf->comparator_type.size() == 1 ? false : true;
    return DbDataValueVecToString(res, composite, name);
}

bool CdbIf::ConstructDbDataValueColumnValue(std::string& res,
    const GenDb::NewCf *cf, const GenDb::DbDataValueVec& value) {
    bool composite = cf->default_validation_class.size() == 1 ? false : true;
    return DbDataValueVecToString(res, composite, value);
}

bool CdbIf::Db_AddColumnfamily(const GenDb::NewCf& cf) {
    if (Db_FindColumnfamily(cf.cfname_)) {
        return true;
    }
    CdbIfStats::ErrorType err_type(
        CdbIfStats::CDBIF_STATS_ERR_WRITE_COLUMN_FAMILY);
    CdbIfStats::CfOp op(
         CdbIfStats::CDBIF_STATS_CF_OP_WRITE_FAIL);
    if (cf.cftype_ == GenDb::NewCf::COLUMN_FAMILY_SQL) {
        cassandra::CfDef cf_def;
        cf_def.__set_keyspace(tablespace_);
        cf_def.__set_name(cf.cfname_);
        cf_def.__set_gc_grace_seconds(0);

        std::string key_valid_class;
        if (!DbDataTypeVecToCompositeType(key_valid_class,
            cf.key_validation_class)) {
            stats_.IncrementErrors(err_type);
            UpdateCfStats(op, cf.cfname_);
            CDBIF_LOG_ERR_RETURN_FALSE(cf.cfname_ << 
                "": KeyValidate encode FAILED"");
        }
        cf_def.__set_key_validation_class(key_valid_class);

        cassandra::ColumnDef col_def;
        std::vector<cassandra::ColumnDef> col_vec;
        GenDb::NewCf::SqlColumnMap::const_iterator it;
        CdbIfTypeMapDef::iterator jt;
        for (it = cf.cfcolumns_.begin(); it != cf.cfcolumns_.end(); it++) {
            col_def.__set_name(it->first);
            if ((jt = CdbIfTypeMap.find(it->second)) == CdbIfTypeMap.end()) {
                stats_.IncrementErrors(err_type);
                UpdateCfStats(op, cf.cfname_);
                CDBIF_LOG_ERR_RETURN_FALSE(cf.cfname_ << "": Unknown type "" << 
                    it->second);
            }
            col_def.__set_validation_class(jt->second.cassandra_type_);
            col_vec.push_back(col_def);
        }
        cf_def.__set_column_metadata(col_vec);

        CdbIfCfInfo *cfinfo;
        if (Db_GetColumnfamily(&cfinfo, cf.cfname_)) {
            if ((*cfinfo->cfdef_.get()).gc_grace_seconds != 0) {
                CDBIF_LOG(DEBUG, ""CFName: "" << cf.cfname_ << "" ID: "" << 
                    (*cfinfo->cfdef_.get()).id);
                cf_def.__set_id((*cfinfo->cfdef_.get()).id);
                CDBIF_BEGIN_TRY {
                    std::string ret;
                    client_->system_update_column_family(ret, cf_def);
                } CDBIF_END_TRY_RETURN_FALSE_INTERNAL(cf.cfname_, false, false,
                    false, err_type, op)
            }
            cfinfo->cf_.reset(new GenDb::NewCf(cf));
        } else {
            CDBIF_BEGIN_TRY {
                std::string ret;
                client_->system_add_column_family(ret, cf_def);
            } CDBIF_END_TRY_RETURN_FALSE_INTERNAL(cf.cfname_, true, false,
                  false, err_type, op)

            CfDef *cfdef_n = new CfDef;
            *cfdef_n = cf_def;
            std::string cfname_n = cf.cfname_;
            CdbIfCfList.insert(cfname_n, new CdbIfCfInfo(cfdef_n,
                new GenDb::NewCf(cf)));
        }
    } else if (cf.cftype_ == GenDb::NewCf::COLUMN_FAMILY_NOSQL) {
        cassandra::CfDef cf_def;
        cf_def.__set_keyspace(tablespace_);
        cf_def.__set_name(cf.cfname_);
        cf_def.__set_gc_grace_seconds(0);
        // Key Validation
        std::string key_valid_class;
        if (!DbDataTypeVecToCompositeType(key_valid_class,
            cf.key_validation_class)) {
            stats_.IncrementErrors(err_type);
            UpdateCfStats(op, cf.cfname_);
            CDBIF_LOG_ERR_RETURN_FALSE(cf.cfname_ << 
                "": KeyValidate encode FAILED"");
        }
        cf_def.__set_key_validation_class(key_valid_class);
        // Comparator
        std::string comparator_type;
        if (!DbDataTypeVecToCompositeType(comparator_type,
            cf.comparator_type)) {
            stats_.IncrementErrors(err_type);
            UpdateCfStats(op, cf.cfname_);
            CDBIF_LOG_ERR_RETURN_FALSE(cf.cfname_ << 
               "": Comparator encode FAILED"");
        }
        cf_def.__set_comparator_type(comparator_type);
        // Validation
        std::string default_validation_class;
        if (!DbDataTypeVecToCompositeType(default_validation_class,
            cf.default_validation_class)) {
            stats_.IncrementErrors(err_type);
            UpdateCfStats(op, cf.cfname_);
            CDBIF_LOG_ERR_RETURN_FALSE(cf.cfname_ << 
                "": Validate encode FAILED"");
        }
        cf_def.__set_default_validation_class(default_validation_class);

        CdbIfCfInfo *cfinfo;
        if (Db_GetColumnfamily(&cfinfo, cf.cfname_)) {
            if ((*cfinfo->cfdef_.get()).gc_grace_seconds != 0) {
                CDBIF_LOG(DEBUG, ""CFName: "" << cf.cfname_ << "" ID: "" << 
                    (*cfinfo->cfdef_.get()).id);
                cf_def.__set_id((*cfinfo->cfdef_.get()).id);
                CDBIF_BEGIN_TRY {
                    std::string ret;
                    client_->system_update_column_family(ret, cf_def);
                } CDBIF_END_TRY_RETURN_FALSE_INTERNAL(cf.cfname_, false, false,
                    false, err_type, op)
            }
            cfinfo->cf_.reset(new GenDb::NewCf(cf));
        } else {
            CDBIF_BEGIN_TRY {
                std::string ret;
                client_->system_add_column_family(ret, cf_def);
            } CDBIF_END_TRY_RETURN_FALSE_INTERNAL(cf.cfname_, true, false,
                false, err_type, op)

            CfDef *cfdef_n = new CfDef;
            *cfdef_n = cf_def;
            std::string cfname_n = cf.cfname_;
            CdbIfCfList.insert(cfname_n, new CdbIfCfInfo(cfdef_n,
                new GenDb::NewCf(cf)));
        }
    } else {
        stats_.IncrementErrors(err_type);
        UpdateCfStats(op, cf.cfname_);
        CDBIF_LOG_ERR_RETURN_FALSE(cf.cfname_ << "": Unknown type "" <<
            cf.cftype_); 
    }
    return true;
}

bool CdbIf::Db_AsyncAddColumn(CdbIfColList &cl) {
    GenDb::ColList *new_colp(cl.gendb_cl);
    if (new_colp == NULL) {
        stats_.IncrementErrors(
            CdbIfStats::CDBIF_STATS_ERR_WRITE_COLUMN);
        CDBIF_LOG_ERR(""No Column Information"");
        return true;
    }
    uint64_t ts(UTCTimestampUsec());
    std::string cfname(new_colp->cfname_);
    // Does the row key exist in the Cassandra mutation map ?
    std::string key_value;
    DbDataValueVecToString(key_value, new_colp->rowkey_.size() != 1,
                           new_colp->rowkey_);
    CassandraMutationMap::iterator cmm_it = mutation_map_.find(key_value);
    if (cmm_it == mutation_map_.end()) {
        cmm_it = mutation_map_.insert(
            std::pair<std::string, CFMutationMap>(key_value,
                CFMutationMap())).first;
    } 
    CFMutationMap &cf_mutation_map(cmm_it->second);
    // Does the column family exist in the column family mutation map ?
    CFMutationMap::iterator cfmm_it = cf_mutation_map.find(cfname);
    if (cfmm_it == cf_mutation_map.end()) {
        cfmm_it = cf_mutation_map.insert(
            std::pair<std::string, MutationList>(cfname, MutationList())).first;
    }
    MutationList &mutations(cfmm_it->second);
    mutations.reserve(mutations.size() + new_colp->columns_.size());

    GenDb::NewCf::ColumnFamilyType cftype = GenDb::NewCf::COLUMN_FAMILY_INVALID;
    for (GenDb::NewColVec::iterator it = new_colp->columns_.begin();
         it != new_colp->columns_.end(); it++) {
        cassandra::Mutation mutation;
        cassandra::ColumnOrSuperColumn c_or_sc;
        cassandra::Column c;

        if (it->cftype_ == GenDb::NewCf::COLUMN_FAMILY_SQL) {
            CDBIF_EXPECT_TRUE_ELSE_RETURN_FALSE((it->name->size() == 1) && 
                                           (it->value->size() == 1));
            CDBIF_EXPECT_TRUE_ELSE_RETURN_FALSE(
                cftype != GenDb::NewCf::COLUMN_FAMILY_NOSQL);
            cftype = GenDb::NewCf::COLUMN_FAMILY_SQL;
            // Column Name
            std::string col_name;
            try {
                col_name = boost::get<std::string>(it->name->at(0));
            } catch (boost::bad_get& ex) {
                CDBIF_LOG_ERR(cfname << ""Column Name FAILED "" << ex.what());
            }
            c.__set_name(col_name);
            // Column Value
            std::string col_value;
            DbDataValueToStringNonComposite(col_value, it->value->at(0));
            c.__set_value(col_value);
            // Timestamp and TTL
            c.__set_timestamp(ts);
            if (it->ttl == -1) {
                if (cassandra_ttl_) {
                    c.__set_ttl(cassandra_ttl_);
                }
            } else if (it->ttl) {
                c.__set_ttl(it->ttl);
            }
            c_or_sc.__set_column(c);
            mutation.__set_column_or_supercolumn(c_or_sc);
            mutations.push_back(mutation);
        } else if (it->cftype_ == GenDb::NewCf::COLUMN_FAMILY_NOSQL) {
            CDBIF_EXPECT_TRUE_ELSE_RETURN_FALSE(
                cftype != GenDb::NewCf::COLUMN_FAMILY_SQL);
            cftype = GenDb::NewCf::COLUMN_FAMILY_NOSQL;
            // Column Name
            std::string col_name;
            DbDataValueVecToString(col_name, it->name->size() != 1, *it->name);
            c.__set_name(col_name);
            // Column Value
            std::string col_value;
            DbDataValueVecToString(col_value, it->value->size() != 1,
                                   *it->value);
            c.__set_value(col_value);
            // Timestamp and TTL
            c.__set_timestamp(ts);
            if (it->ttl == -1) {
                if (cassandra_ttl_) {
                    c.__set_ttl(cassandra_ttl_);
                }
            } else if (it->ttl) {
                c.__set_ttl(it->ttl);
            }
            c_or_sc.__set_column(c);
            mutation.__set_column_or_supercolumn(c_or_sc);
            mutations.push_back(mutation);
        } else {
            stats_.IncrementErrors(
                CdbIfStats::CDBIF_STATS_ERR_WRITE_COLUMN);
            UpdateCfWriteFailStats(cfname);
            CDBIF_LOG_ERR_RETURN_FALSE(cfname << "": Invalid CFtype: "" << 
                it->cftype_);
        }
    }
    // Update write stats
    UpdateCfWriteStats(cfname);
    // Allocated when enqueued, free it after processing
    delete new_colp;
    cl.gendb_cl = NULL;
    return true;
}

void CdbIf::Db_BatchAddColumn(bool done) {
    CDBIF_BEGIN_TRY {
        client_->batch_mutate(mutation_map_,
            org::apache::cassandra::ConsistencyLevel::ONE);
    } CDBIF_END_TRY_LOG_INTERNAL(integerToString(mutation_map_.size()),
          false, false, true, CdbIfStats::CDBIF_STATS_ERR_WRITE_BATCH_COLUMN,
          CdbIfStats::CDBIF_STATS_CF_OP_NONE)
    mutation_map_.clear();
}

bool CdbIf::Db_AddColumn(std::auto_ptr<GenDb::ColList> cl) {
    tbb::mutex::scoped_lock lock(cdbq_mutex_);
    if (!Db_IsInitDone() || !cdbq_.get()) {
        UpdateCfWriteFailStats(cl->cfname_);
        return false;
    }
    CdbIfColList qentry;
    qentry.gendb_cl = cl.release();
    cdbq_->Enqueue(qentry);
    return true;
}

bool CdbIf::Db_AddColumnSync(std::auto_ptr<GenDb::ColList> cl) {
    CdbIfColList qentry;
    std::string cfname(cl->cfname_);
    qentry.gendb_cl = cl.release();
    bool success = Db_AsyncAddColumn(qentry);
    if (!success) {
        UpdateCfWriteFailStats(cfname);
        return success;
    }
    Db_BatchAddColumn(true);
    return true;
}

bool CdbIf::ColListFromColumnOrSuper(GenDb::ColList& ret,
        std::vector<cassandra::ColumnOrSuperColumn>& result,
        const std::string& cfname) {
    CdbIfCfInfo *info;
    GenDb::NewCf *cf;
    if (!Db_GetColumnfamily(&info, cfname) || !(cf = info->cf_.get())) {
        CDBIF_LOG_ERR_RETURN_FALSE(cfname << "": NOT FOUND""); 
    }
    if (cf->cftype_ == NewCf::COLUMN_FAMILY_SQL) {
        NewColVec& columns = ret.columns_;
        std::vector<cassandra::ColumnOrSuperColumn>::iterator citer;
        for (citer = result.begin(); citer != result.end(); citer++) {
            GenDb::DbDataValue res;
            if (!DbDataValueFromString(res, cfname, citer->column.name,
                citer->column.value)) {
                CDBIF_LOG_ERR(cfname << "": "" << citer->column.name << 
                    "" Decode FAILED"");
                continue;
            }
            GenDb::NewCol *col(new GenDb::NewCol(citer->column.name, res));
            columns.push_back(col);
        }
    } else if (cf->cftype_ == NewCf::COLUMN_FAMILY_NOSQL) {
        NewColVec& columns = ret.columns_;
        std::vector<cassandra::ColumnOrSuperColumn>::iterator citer;
        for (citer = result.begin(); citer != result.end(); citer++) {
            std::auto_ptr<GenDb::DbDataValueVec> name(new GenDb::DbDataValueVec);
            if (!DbDataValueVecFromString(*name, cf->comparator_type, 
                citer->column.name)) {
                CDBIF_LOG_ERR(cfname << "": Column Name Decode FAILED"");
                continue;
            }
            std::auto_ptr<GenDb::DbDataValueVec> value(new GenDb::DbDataValueVec);
            if (!DbDataValueVecFromString(*value, cf->default_validation_class,
                    citer->column.value)) {
                CDBIF_LOG_ERR(cfname << "": Column Value Decode FAILED"");
                continue;
            }
            GenDb::NewCol *col(new GenDb::NewCol(name.release(), value.release()));
            columns.push_back(col);
        }
    }
    return true;
}

bool CdbIf::Db_GetRow(GenDb::ColList& ret, const std::string& cfname,
        const DbDataValueVec& rowkey) {
    CdbIfCfInfo *info;
    GenDb::NewCf *cf;
    if (!Db_GetColumnfamily(&info, cfname) || !(cf = info->cf_.get())) {
        stats_.IncrementErrors(
            CdbIfStats::CDBIF_STATS_ERR_READ_COLUMN_FAMILY);
        UpdateCfReadFailStats(cfname);
        CDBIF_LOG_ERR_RETURN_FALSE(cfname << "": NOT FOUND""); 
    }
    std::string key;
    if (!ConstructDbDataValueKey(key, cf, rowkey)) {
        UpdateCfReadFailStats(cfname);
        CDBIF_LOG_ERR_RETURN_FALSE(cfname << "": Key encode FAILED"");
    }
    // Slicer has start_column and end_column as null string, which
    // means return all columns
    cassandra::SliceRange slicer;
    cassandra::SlicePredicate slicep;
    slicep.__set_slice_range(slicer);
    cassandra::ColumnParent cparent;
    cparent.column_family.assign(cfname);
    std::vector<cassandra::ColumnOrSuperColumn> result;
    CDBIF_BEGIN_TRY {
        client_->get_slice(result, key, cparent, slicep,
            ConsistencyLevel::ONE);
    } CDBIF_END_TRY_RETURN_FALSE_INTERNAL(cfname, false, false, false,
        CdbIfStats::CDBIF_STATS_ERR_READ_COLUMN,
        CdbIfStats::CDBIF_STATS_CF_OP_READ_FAIL)
    bool success = ColListFromColumnOrSuper(ret, result, cfname);
    if (success) {
        UpdateCfReadStats(cfname);
    } else {
        UpdateCfReadFailStats(cfname);
    }
    return success;
}

bool CdbIf::Db_GetMultiRow(GenDb::ColListVec& ret, const std::string& cfname,
    const std::vector<DbDataValueVec>& rowkeys,
    GenDb::ColumnNameRange *crange_ptr) {
    CdbIfCfInfo *info;
    GenDb::NewCf *cf;
    if (!Db_GetColumnfamily(&info, cfname) || !(cf = info->cf_.get())) {
        stats_.IncrementErrors(
            CdbIfStats::CDBIF_STATS_ERR_READ_COLUMN_FAMILY);
        UpdateCfReadFailStats(cfname);
        CDBIF_LOG_ERR_RETURN_FALSE(cfname << "": NOT FOUND""); 
    }
    // Populate column name range slice
    cassandra::SliceRange slicer;
    cassandra::SlicePredicate slicep;
    if (crange_ptr) {
        // Column range specified, set appropriate variables
        std::string start_string;
        if (!ConstructDbDataValueColumnName(start_string, cf,
            crange_ptr->start_)) {
            UpdateCfReadFailStats(cfname);
            CDBIF_LOG_ERR_RETURN_FALSE(cfname <<
                "": Column Name Range Start encode FAILED"");
        }
        std::string finish_string;
        if (!ConstructDbDataValueColumnName(finish_string, cf,
            crange_ptr->finish_)) {
            UpdateCfReadFailStats(cfname);
            CDBIF_LOG_ERR_RETURN_FALSE(cfname <<
                "": Column Name Range Finish encode FAILED"");
        }
        slicer.__set_start(start_string);
        slicer.__set_finish(finish_string);
        slicer.__set_count(crange_ptr->count);
    }
    // If column range is not specified, slicer has start_column and 
    // end_column as null string, which means return all columns
    slicep.__set_slice_range(slicer);
    cassandra::ColumnParent cparent;
    cparent.column_family.assign(cfname);
    // Do query for keys in batches
    std::vector<DbDataValueVec>::const_iterator it = rowkeys.begin();
    while (it != rowkeys.end())  {
        std::vector<std::string> keys;
        for (int i = 0; (it != rowkeys.end()) && (i <= kMaxQueryRows); 
                it++, i++) {
            std::string key;
            if (!ConstructDbDataValueKey(key, cf, *it)) {
                UpdateCfReadFailStats(cfname);
                CDBIF_LOG_ERR_RETURN_FALSE(cfname << ""("" << i << 
                    ""): Key encode FAILED"");
            }
            keys.push_back(key);
        }
        std::map<std::string, std::vector<ColumnOrSuperColumn> > ret_c;
        CDBIF_BEGIN_TRY {
            client_->multiget_slice(ret_c, keys, cparent, slicep, ConsistencyLevel::ONE);
        } CDBIF_END_TRY_RETURN_FALSE_INTERNAL(cfname, false, false, false,
            CdbIfStats::CDBIF_STATS_ERR_READ_COLUMN,
            CdbIfStats::CDBIF_STATS_CF_OP_READ_FAIL)
        // Update stats
        UpdateCfReadStats(cfname);
        // Convert result
        for (std::map<std::string, 
                 std::vector<ColumnOrSuperColumn> >::iterator it = ret_c.begin();
             it != ret_c.end(); it++) {
            std::auto_ptr<GenDb::ColList> col_list(new GenDb::ColList);
            if (!DbDataValueVecFromString(col_list->rowkey_,
                cf->key_validation_class, it->first)) {
                CDBIF_LOG_ERR(cfname << "": Key decode FAILED"");
                continue;
            }
            if (!ColListFromColumnOrSuper(*col_list, it->second, cfname)) {
                CDBIF_LOG_ERR(cfname << "": Column decode FAILED"");
            } 
            ret.push_back(col_list);
        }
    } // while loop
    return true;
}

bool CdbIf::Db_GetRangeSlices(GenDb::ColList& col_list,
    const std::string& cfname, const GenDb::ColumnNameRange& crange,
    const GenDb::DbDataValueVec& rowkey) {
    CdbIfCfInfo *info;
    GenDb::NewCf *cf;
    if (!Db_GetColumnfamily(&info, cfname) || !(cf = info->cf_.get())) {
        stats_.IncrementErrors(
            CdbIfStats::CDBIF_STATS_ERR_READ_COLUMN_FAMILY);
        UpdateCfReadFailStats(cfname);
        CDBIF_LOG_ERR_RETURN_FALSE(cfname << "": NOT FOUND""); 
    }
    bool result = 
        Db_GetRangeSlicesInternal(col_list, cf, crange, rowkey);
    bool col_limit_reached = (col_list.columns_.size() == crange.count);
    GenDb::ColumnNameRange crange_new = crange;
    if (col_limit_reached && (col_list.columns_.size()>0)) {
        // copy last entry of result returned as column start for next qry
        crange_new.start_ = *(col_list.columns_.back()).name;
    }
    // extract rest of the result
    while (col_limit_reached && result) {
        GenDb::ColList next_col_list;
        result = 
            Db_GetRangeSlicesInternal(next_col_list, cf, crange_new, rowkey);
        col_limit_reached = 
            (next_col_list.columns_.size() == crange.count);
        // copy last entry of result returned as column start for next qry
        if (col_limit_reached && (next_col_list.columns_.size()>0)) {
            crange_new.start_ = *(next_col_list.columns_.back()).name;
        }
        // copy result after the first entry
        NewColVec::iterator it = next_col_list.columns_.begin();
        if (it != next_col_list.columns_.end()) it++;
        col_list.columns_.transfer(col_list.columns_.end(), it,
            next_col_list.columns_.end(), next_col_list.columns_);
    }
    return result;
}

bool CdbIf::Db_GetRangeSlicesInternal(GenDb::ColList& col_list,
    const GenDb::NewCf *cf, const GenDb::ColumnNameRange& crange,
    const GenDb::DbDataValueVec& rowkey) {
    const std::string &cfname(cf->cfname_);

    cassandra::ColumnParent cparent;
    cparent.column_family.assign(cfname);
    cparent.super_column.assign("""");
    // Key
    std::string key_string;
    if (!ConstructDbDataValueKey(key_string, cf, rowkey)) {
        UpdateCfReadFailStats(cfname);
        CDBIF_LOG_ERR_RETURN_FALSE(cfname << "": Key encode FAILED"");
    }
    cassandra::KeyRange krange;
    krange.__set_start_key(key_string);
    krange.__set_end_key(key_string);
    krange.__set_count(1);
    // Column Range
    std::string start_string;
    if (!ConstructDbDataValueColumnName(start_string, cf, crange.start_)) {
        UpdateCfReadFailStats(cfname);
        CDBIF_LOG_ERR_RETURN_FALSE(cfname <<
            "": Column Name Range Start encode FAILED"");
    }
    std::string finish_string;
    if (!ConstructDbDataValueColumnName(finish_string, cf, crange.finish_)) {
        UpdateCfReadFailStats(cfname);
        CDBIF_LOG_ERR_RETURN_FALSE(cfname <<
            "": Column Name Range Finish encode FAILED"");
    }
    cassandra::SlicePredicate slicep;
    cassandra::SliceRange slicer;
    slicer.__set_start(start_string);
    slicer.__set_finish(finish_string);
    slicer.__set_count(crange.count);
    slicep.__set_slice_range(slicer);

    std::vector<cassandra::KeySlice> result;
    CDBIF_BEGIN_TRY {
        client_->get_range_slices(result, cparent, slicep, krange, ConsistencyLevel::ONE);
    } CDBIF_END_TRY_RETURN_FALSE_INTERNAL(cfname, false, false, false,
        CdbIfStats::CDBIF_STATS_ERR_READ_COLUMN,
        CdbIfStats::CDBIF_STATS_CF_OP_READ_FAIL)
    // Convert result 
    CDBIF_EXPECT_TRUE_ELSE_RETURN_FALSE(result.size() <= 1);
    if (result.size() == 1) {
        cassandra::KeySlice& ks = result[0];
        if (!ColListFromColumnOrSuper(col_list, ks.columns, cfname)) {
            CDBIF_LOG_ERR(cfname << "": Column decode FAILED"");
        }
    }
    return true;
}

bool CdbIf::Db_GetQueueStats(uint64_t &queue_count, uint64_t &enqueues) const {
    if (cdbq_.get() != NULL) {
        queue_count = cdbq_->Length();
        enqueues = cdbq_->NumEnqueues();
    } else {
        queue_count = 0;
        enqueues = 0;
    }
    return true;
}

bool CdbIf::Db_GetStats(std::vector<DbTableInfo> *vdbti, DbErrors *dbe) {
    tbb::mutex::scoped_lock lock(smutex_);
    stats_.Get(vdbti, dbe);
    return true;
}
       
void CdbIf::UpdateCfWriteStats(const std::string &cf_name) {
    tbb::mutex::scoped_lock lock(smutex_);
    stats_.UpdateCf(cf_name, true, false);
}

void CdbIf::UpdateCfWriteFailStats(const std::string &cf_name) {
    tbb::mutex::scoped_lock lock(smutex_);
    stats_.UpdateCf(cf_name, true, true);
}

void CdbIf::UpdateCfReadStats(const std::string &cf_name) {
    tbb::mutex::scoped_lock lock(smutex_);
    stats_.UpdateCf(cf_name, false, false);
}

void CdbIf::UpdateCfReadFailStats(const std::string &cf_name) {
    tbb::mutex::scoped_lock lock(smutex_);
    stats_.UpdateCf(cf_name, false, true);
}

void CdbIf::UpdateCfStats(CdbIf::CdbIfStats::CfOp op,
    const std::string &cf_name) {
    switch (op) {
    case CdbIfStats::CDBIF_STATS_CF_OP_NONE:
        break;
    case CdbIfStats::CDBIF_STATS_CF_OP_WRITE:
        UpdateCfWriteStats(cf_name);
        break;
    case CdbIfStats::CDBIF_STATS_CF_OP_WRITE_FAIL:
        UpdateCfWriteFailStats(cf_name);
        break;
    case CdbIfStats::CDBIF_STATS_CF_OP_READ:
        UpdateCfReadStats(cf_name);
        break;
    case CdbIfStats::CDBIF_STATS_CF_OP_READ_FAIL:
        UpdateCfReadFailStats(cf_name);
        break;
    default:
        break;
    }
}

// CdbIfStats
void CdbIf::CdbIfStats::UpdateCf(const std::string &cfname, bool write,
    bool fail) {
    cf_stats_.Update(cfname, write, fail);
}

void CdbIf::CdbIfStats::IncrementErrors(CdbIf::CdbIfStats::ErrorType type) {
    switch (type) {
    case CdbIfStats::CDBIF_STATS_ERR_WRITE_TABLESPACE:
        db_errors_.write_tablespace_fails++;
        break;
    case CdbIfStats::CDBIF_STATS_ERR_READ_TABLESPACE:
        db_errors_.read_tablespace_fails++;
        break;
    case CdbIfStats::CDBIF_STATS_ERR_WRITE_COLUMN_FAMILY:
        db_errors_.write_column_family_fails++;
        break;
    case CdbIfStats::CDBIF_STATS_ERR_READ_COLUMN_FAMILY:
        db_errors_.read_column_family_fails++;
        break;
    case CdbIfStats::CDBIF_STATS_ERR_WRITE_COLUMN:
        db_errors_.write_column_fails++;
        break;
    case CdbIfStats::CDBIF_STATS_ERR_WRITE_BATCH_COLUMN:
        db_errors_.write_batch_column_fails++;
        break;
    case CdbIfStats::CDBIF_STATS_ERR_READ_COLUMN:
        db_errors_.read_column_fails++;
        break;
    default:
        break;
    }
}

void CdbIf::CdbIfStats::Get(std::vector<DbTableInfo> *vdbti,
    DbErrors *dbe) {
    // Get diff cfstats
    cf_stats_.Get(vdbti);
    // Subtract old from new
    CdbIf::CdbIfStats::Errors derrors(db_errors_ - odb_errors_);
    // Update old
    odb_errors_ = db_errors_;
    // Populate from diff 
    derrors.Get(dbe);
}

// Errors
CdbIf::CdbIfStats::Errors operator+(const CdbIf::CdbIfStats::Errors &a,
    const CdbIf::CdbIfStats::Errors &b) {
    CdbIf::CdbIfStats::Errors sum;
    sum.write_tablespace_fails = a.write_tablespace_fails + 
        b.write_tablespace_fails;
    sum.read_tablespace_fails = a.read_tablespace_fails +
        b.read_tablespace_fails;
    sum.write_column_family_fails = a.write_column_family_fails +
        b.write_column_family_fails;
    sum.read_column_family_fails = a.read_column_family_fails +
        b.read_column_family_fails;
    sum.write_column_fails = a.write_column_fails + b.write_column_fails;
    sum.write_batch_column_fails = a.write_batch_column_fails +
        b.write_batch_column_fails;
    sum.read_column_fails = a.read_column_fails + b.read_column_fails;
    return sum;
}

CdbIf::CdbIfStats::Errors operator-(const CdbIf::CdbIfStats::Errors &a,
    const CdbIf::CdbIfStats::Errors &b) {
    CdbIf::CdbIfStats::Errors diff;
    diff.write_tablespace_fails = a.write_tablespace_fails -
        b.write_tablespace_fails;
    diff.read_tablespace_fails = a.read_tablespace_fails -
        b.read_tablespace_fails;
    diff.write_column_family_fails = a.write_column_family_fails -
        b.write_column_family_fails;
    diff.read_column_family_fails = a.read_column_family_fails -
        b.read_column_family_fails;
    diff.write_column_fails = a.write_column_fails - b.write_column_fails;
    diff.write_batch_column_fails = a.write_batch_column_fails -
        b.write_batch_column_fails;
    diff.read_column_fails = a.read_column_fails - b.read_column_fails;
    return diff;
}

void CdbIf::CdbIfStats::Errors::Get(DbErrors *db_errors) const {
    db_errors->set_write_tablespace_fails(write_tablespace_fails);
    db_errors->set_read_tablespace_fails(read_tablespace_fails);
    db_errors->set_write_table_fails(write_column_family_fails);
    db_errors->set_read_table_fails(read_column_family_fails);
    db_errors->set_write_column_fails(write_column_fails);
    db_errors->set_write_batch_column_fails(write_batch_column_fails);
    db_errors->set_read_column_fails(read_column_fails);
}
",16303,True,2592.936447068458,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 can not weigh them against each other.
Yet, despite that we can not 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.
* `SimpleDoubleScore` uses a `double` value instead of an `int` value. <<avoidFloatingPointNumbersInScoreCalculation,Not recommended to use.>>
* `SimpleBigDecimalScore` uses a `BigDecimal` value instead of an `int` value.


[[hardSoftScore]]
=== `HardSoftScore` (Recommended)

A `HardSoftScore` has a hard `int` value and a soft `int` value, for example ``-123hard/-456soft``.
It has 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.
* `HardSoftDoubleScore` uses `double` values instead of `int` values. <<avoidFloatingPointNumbersInScoreCalculation,Not recommended to use.>>
* `HardSoftBigDecimalScore` uses `BigDecimal` values instead of `int` values.


[[hardMediumSoftScore]]
=== `HardMediumSoftScore`

A `HardMediumSoftScore` which has a hard `int` value, a medium `int` value and a soft `int` value, for example ``-123hard/-456medium/-789soft``.
It has 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 calculateScore(Solution_ solution);

}
----

For example in n queens:

[source,java,options=""nowrap""]
----
public class NQueensEasyScoreCalculator implements EasyScoreCalculator<NQueens> {

    public SimpleScore calculateScore(NQueens nQueens) {
        int n = nQueens.getN();
        List<Queen> queenList = nQueens.getQueenList();

        int score = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                Queen leftQueen = queenList.get(i);
                Queen rightQueen = queenList.get(j);
                if (leftQueen.getRow() != null && rightQueen.getRow() != null) {
                    if (leftQueen.getRowIndex() == rightQueen.getRowIndex()) {
                        score--;
                    }
                    if (leftQueen.getAscendingDiagonalIndex() == rightQueen.getAscendingDiagonalIndex()) {
                        score--;
                    }
                    if (leftQueen.getDescendingDiagonalIndex() == rightQueen.getDescendingDiagonalIndex()) {
                        score--;
                    }
                }
            }
        }
        return SimpleScore.valueOf(score);
    }

}
----

Configure it in the solver configuration:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <easyScoreCalculatorClass>org.optaplanner.examples.nqueens.solver.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>
      <myCacheSize>1000</myCacheSize>
    </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`
and extend the class ``AbstractIncrementalScoreCalculator``:

[source,java,options=""nowrap""]
----
public interface IncrementalScoreCalculator<Solution_> {

    void resetWorkingSolution(Solution_ workingSolution);

    void beforeEntityAdded(Object entity);

    void afterEntityAdded(Object entity);

    void beforeVariableChanged(Object entity, String variableName);

    void afterVariableChanged(Object entity, String variableName);

    void beforeEntityRemoved(Object entity);

    void afterEntityRemoved(Object entity);

    Score calculateScore();

}
----

image::ScoreCalculation/incrementalScoreCalculatorSequenceDiagram.png[align=""center""]

For example in n queens:

[source,java,options=""nowrap""]
----
public class NQueensAdvancedIncrementalScoreCalculator extends AbstractIncrementalScoreCalculator<NQueens> {

    private Map<Integer, List<Queen>> rowIndexMap;
    private Map<Integer, List<Queen>> ascendingDiagonalIndexMap;
    private Map<Integer, List<Queen>> descendingDiagonalIndexMap;

    private int score;

    public void resetWorkingSolution(NQueens nQueens) {
        int n = nQueens.getN();
        rowIndexMap = new HashMap<Integer, List<Queen>>(n);
        ascendingDiagonalIndexMap = new HashMap<Integer, List<Queen>>(n * 2);
        descendingDiagonalIndexMap = new HashMap<Integer, List<Queen>>(n * 2);
        for (int i = 0; i < n; i++) {
            rowIndexMap.put(i, new ArrayList<Queen>(n));
            ascendingDiagonalIndexMap.put(i, new ArrayList<Queen>(n));
            descendingDiagonalIndexMap.put(i, new ArrayList<Queen>(n));
            if (i != 0) {
                ascendingDiagonalIndexMap.put(n - 1 + i, new ArrayList<Queen>(n));
                descendingDiagonalIndexMap.put((-i), new ArrayList<Queen>(n));
            }
        }
        score = 0;
        for (Queen queen : nQueens.getQueenList()) {
            insert(queen);
        }
    }

    public void beforeEntityAdded(Object entity) {
        // Do nothing
    }

    public void afterEntityAdded(Object entity) {
        insert((Queen) entity);
    }

    public void beforeVariableChanged(Object entity, String variableName) {
        retract((Queen) entity);
    }

    public void afterVariableChanged(Object entity, String variableName) {
        insert((Queen) entity);
    }

    public void beforeEntityRemoved(Object entity) {
        retract((Queen) entity);
    }

    public void afterEntityRemoved(Object entity) {
        // Do nothing
    }

    private void insert(Queen queen) {
        Row row = queen.getRow();
        if (row != null) {
            int rowIndex = queen.getRowIndex();
            List<Queen> rowIndexList = rowIndexMap.get(rowIndex);
            score -= rowIndexList.size();
            rowIndexList.add(queen);
            List<Queen> ascendingDiagonalIndexList = ascendingDiagonalIndexMap.get(queen.getAscendingDiagonalIndex());
            score -= ascendingDiagonalIndexList.size();
            ascendingDiagonalIndexList.add(queen);
            List<Queen> descendingDiagonalIndexList = descendingDiagonalIndexMap.get(queen.getDescendingDiagonalIndex());
            score -= descendingDiagonalIndexList.size();
            descendingDiagonalIndexList.add(queen);
        }
    }

    private void retract(Queen queen) {
        Row row = queen.getRow();
        if (row != null) {
            List<Queen> rowIndexList = rowIndexMap.get(queen.getRowIndex());
            rowIndexList.remove(queen);
            score += rowIndexList.size();
            List<Queen> ascendingDiagonalIndexList = ascendingDiagonalIndexMap.get(queen.getAscendingDiagonalIndex());
            ascendingDiagonalIndexList.remove(queen);
            score += ascendingDiagonalIndexList.size();
            List<Queen> descendingDiagonalIndexList = descendingDiagonalIndexMap.get(queen.getDescendingDiagonalIndex());
            descendingDiagonalIndexList.remove(queen);
            score += descendingDiagonalIndexList.size();
        }
    }

    public SimpleScore calculateScore() {
        return SimpleScore.valueOf(score);
    }

}
----

Configure it in the solver configuration:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <incrementalScoreCalculatorClass>org.optaplanner.examples.nqueens.solver.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>
      <myCacheSize>1000</myCacheSize>
    </incrementalScoreCalculatorCustomProperties>
  </scoreDirectorFactory>
----


[[constraintMatchAwareIncrementalScoreCalculator]]
==== `ConstraintMatchAwareIncrementalScoreCalculator`

Optionally, also implement the `ConstraintMatchAwareIncrementalScoreCalculator` interface to:

* Explain a score by splitting it up per score constraint with `ScoreDirector.getConstraintMatchTotals()`.
* Visualize or sort planning entities by how many constraints each one breaks with `ScoreDirector.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_> {

    void resetWorkingSolution(Solution_ workingSolution, boolean constraintMatchEnabled);

    Collection<ConstraintMatchTotal> getConstraintMatchTotals();

    Map<Object, Indictment> 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> {
    ...

    @Override
    public void resetWorkingSolution(MachineReassignment workingSolution, boolean constraintMatchEnabled) {
        resetWorkingSolution(workingSolution);
        // ignore constraintMatchEnabled, it is always presumed enabled
    }

    @Override
    public Collection<ConstraintMatchTotal> getConstraintMatchTotals() {
        ConstraintMatchTotal maximumCapacityMatchTotal = new ConstraintMatchTotal(
                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> constraintMatchTotalList = new ArrayList<>(4);
        constraintMatchTotalList.add(maximumCapacityMatchTotal);
        ...
        return constraintMatchTotalList;
    }

    @Override
    public Map<Object, Indictment> getIndictmentMap() {
        return null; // Calculate it non-incrementally from getConstraintMatchTotals()
    }
}
----

That `getConstraintMatchTotals()` code often duplicates some of the logic of the normal `IncrementalScoreCalculator` methods.
Drools Score Calculation doesn't have this disadvantage, because it is 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 can not unmatch a positive constraint that was matched by a previous initialized variable.
* ``ONLY_DOWN``: Initializing an extra variable can only change the score negatively. Implies that:
** There are only negative constraints
** And initializing the next variable can not unmatch a negative constraint that was matched by a previous initialized variable.

Most use cases only have negative constraints.
Many of those have an `InitializingScoreTrend` that only goes down:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <scoreDrl>.../cloudBalancingScoreRules.drl</scoreDrl>
    <initializingScoreTrend>ONLY_DOWN</initializingScoreTrend>
  </scoreDirectorFactory>
----

Alternatively, you can also specify the trend for each score level separately:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <scoreDrl>.../cloudBalancingScoreRules.drl</scoreDrl>
    <initializingScoreTrend>ONLY_DOWN/ONLY_DOWN</initializingScoreTrend>
  </scoreDirectorFactory>
----


[[invalidScoreDetection]]
=== Invalid score detection

When you put 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 score rule might consistently match the wrong pattern.
To verify the score rules against an independent implementation, configure a ``assertionScoreDirectorFactory``:

[source,xml,options=""nowrap""]
----
  <environmentMode>FAST_ASSERT</environmentMode>
  ...
  <scoreDirectorFactory>
    <scoreDrl>org/optaplanner/examples/nqueens/solver/nQueensScoreRules.drl</scoreDrl>
    <assertionScoreDirectorFactory>
      <easyScoreCalculatorClass>org.optaplanner.examples.nqueens.solver.score.NQueensEasyScoreCalculator</easyScoreCalculatorClass>
    </assertionScoreDirectorFactory>
  </scoreDirectorFactory>
----

This way, the `scoreDrl` will be validated by the ``EasyScoreCalculator``.

[NOTE]
====
This works well to isolate score corruption,
but to verify that the score rules implement the real business needs,
<<testingScoreConstraints, a unit test with a ScoreVerifier>> is usually better.
====


[[scoreCalculationPerformanceTricks]]
== Score calculation performance tricks


[[scoreCalculationPerformanceTricksOverview]]
=== Overview

The `Solver` will normally spend most of its execution time running the score calculation
(which is called in its deepest loops).
Faster score calculation will return the same solution in less time with the same algorithm,
which normally means a better solution in equal time.


[[scoreCalculationSpeed]]
=== Score calculation speed

After solving a problem, the `Solver` will log the __score calculation speed per second__.
This is a good measurement of Score calculation performance,
despite that it is affected by non score calculation execution time.
It depends on the problem scale of the problem dataset.
Normally, even for high scale problems, it is higher than ``1000``, except 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 `explainBestScore()`,
but only use that method for diagnostic purposes:

[source,java,options=""nowrap""]
----
System.out.println(solver.explainBestScore());
----

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,
reuse the `ScoreDirectorFactory` of the `SolverFactory` to build a separate `ScoreDirector` for that webUI:

[source,java,options=""nowrap""]
----
ScoreDirectorFactory<CloudBalance> scoreDirectorFactory = solverFactory.getScoreDirectorFactory();
try (ScoreDirector<CloudBalance> guiScoreDirector = scoreDirectorFactory.buildScoreDirector()) {
    ...
}
----

[NOTE]
====
The `try` ARM will call `ScoreDirector.close()` when the `ScoreDirector` becomes useless,
to avoid a memory leak, especially with <<droolsScoreCalculation,Drools score calculation>>.
====

Then use it when you need to calculate the `Score` of a solution:

[source,java,options=""nowrap""]
----
guiScoreDirector.setWorkingSolution(cloudBalance);
Score score = guiScoreDirector.calculateScore();
----

Furthermore, the `ScoreDirector` can 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 (so per score rule with Drools score calculation),
get the ``ConstraintMatchTotal``s from the ``ScoreDirector``:

[source,java,options=""nowrap""]
----
Collection<ConstraintMatchTotal> constraintMatchTotals = guiScoreDirector.getConstraintMatchTotals();
for (ConstraintMatchTotal constraintMatchTotal : constraintMatchTotals) {
    String constraintName = constraintMatchTotal.getConstraintName();
    // The score impact of that constraint
    HardSoftScore totalScore = (HardSoftScore) constraintMatchTotal.getScore();

    for (ConstraintMatch constraintMatch : constraintMatchTotal.getConstraintMatchSet()) {
        List<Object> justificationList = constraintMatch.getJustificationList();
        HardSoftScore score = (HardSoftScore) constraintMatch.getScore();
        ...
    }
}
----

Each `ConstraintMatchTotal` represents one constraint (so one score rule) and has a part of the overall score.
The sum of all the `ConstraintMatchTotal.getScore()` equals the overall score.

[NOTE]
====
<<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 ``ScoreDirector``:

[source,java,options=""nowrap""]
----
Map<Object, Indictment> indictmentMap = guiScoreDirector.getIndictmentMap();
for (CloudProcess process : cloudBalance.getProcessList()) {
    Indictment indictment = indictmentMap.get(process);
    if (indictment == null) {
        continue;
    }
    // The score impact of that planning entity
    HardSoftScore totalScore = (HardSoftScore) indictment.getScore();

    for (ConstraintMatch constraintMatch : indictment.getConstraintMatchSet()) {
        String constraintName = constraintMatch.getConstraintName();
        HardSoftScore score = (HardSoftScore) 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]
====
<<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>>.
",12144,False,2113.612277800984,median
"[[user-guide]]
= MyBatis Thymeleaf User's Guide
:author: The MyBatis Team
:revnumber: x.x.x
:revdate: {localdate}
:toc: left
:icons: font
:source-highlighter: coderay
:imagesdir: ./images
:imagesoutdir: ./images
:docinfodir: ./docinfos
:docinfo1:
:sectnums:
:nofooter:
:sectlinks:
:linkcss:
:xrefstyle: full

// Define variable for urls
:mybatis-doc-url: http://www.mybatis.org/mybatis-3
:ci-url: https://github.com/mybatis/thymeleaf-scripting/actions/workflows/ci.yaml
:thymeleaf-doc-url: https://www.thymeleaf.org/doc/tutorials/3.0
:github-organization-url: https://github.com/mybatis
:github-url: {github-organization-url}/thymeleaf-scripting
:github-wiki-url: {github-url}/wiki

// Define dependency artifact versions
:mybatis-version: y.y.y

== Overview

=== What is MyBatis Thymeleaf ?

The mybatis-thymeleaf is a plugin that helps applying the 2-way SQL/dynamic SQL feature to the MyBatis 3
using the template mechanism provided by Thymeleaf 3.
If you are not familiar with MyBatis and Thymeleaf, you can see following official documentations.

* {mybatis-doc-url}[MyBatis 3 REFERENCE DOCUMENTATION^]
* {thymeleaf-doc-url}/usingthymeleaf.html[Tutorial: Using Thymeleaf^]
* {thymeleaf-doc-url}/usingthymeleaf.html#textual-template-modes[Tutorial: Using Thymeleaf -13 Textual template modes-^]

=== What is 2-way SQL?

The 2-way SQL can be used by following *two way*.

* It can be executed as-is in SQL execution tool (such as psql, mysql, sqlplus, plugins for IDE, etc...)
* It can be used as a SQL template for creating a bindable and dynamically SQL that can be parsed by MyBatis core module

==== Simple bindable 2-way SQL

The mybatis-thymeleaf support a simple bindable 2-way SQL as follow:


[source,sql]
.SQL Template
----
SELECT * FROM names
  WHERE id = /*[# mb:p=""id""]*/ 1 /*[/]*/
----


==== Dynamically bindable 2-way SQL

The mybatis-thymeleaf support a dynamically bindable 2-way SQL as follow:

[source,sql]
.SQL Template
----
SELECT * FROM names
  WHERE 1 = 1
  /*[# th:if=""${not #lists.isEmpty(ids)}""]*/
    AND id IN (/*[# mb:p=""ids""]*/ 1 /*[/]*/)
  /*[/]*/
  ORDER BY id
----

==== Dynamically bindable SQL

The mybatis-thymeleaf support a dynamically bindable SQL(non 2-way SQL) as follow:

[source,sql]
.SQL Template
----
SELECT * FROM names
  WHERE 1 = 1
  [# th:if=""${not #lists.isEmpty(ids)}""]
    AND id IN ([# mb:p=""ids"" /])
  [/]
  ORDER BY id
----


=== Mainly Features

The mybatis-thymeleaf provide following features using class that implements
the link:{mybatis-doc-url}/dynamic-sql.html#Pluggable_Scripting_Languages_For_Dynamic_SQL[`LanguageDriver` interface^]
for integrating with template engine provide by Thymeleaf.

* Can write 2-way SQL/dynamic SQL
* Can use a 2-way SQL/dynamic SQL via an annotation and mapper xml
* Can read an SQL template from a Thymeleaf template file on classpath
* Can use a custom dialect(attribute tag and expression utility method) on your SQL template
* Can fully customize a template engine configuration
* Can generate the SQL from SQL template without the MyBatis core module (since 1.0.2)

== Requirements

The mybatis-thymeleaf supports using on following Java and artifacts version.

=== Java

* Java 8, Java 11+

[NOTE]
====
About tested versions see the latest link:{ci-url}[CI^] build result.
====

=== MyBatis

* MyBatis 3.4.3+

[NOTE]
====
As basically policy, we do test using following versions.

* latest release version on 3.5.x line
* latest snapshot version on 3.5.x line
* latest release version on 3.4.x line
====

=== Thymeleaf

* Thymeleaf 3.0+

[NOTE]
====
As basically policy, we do test using following versions.

* latest release version on 3.0.x line
====

== Getting Started

In this chapter, we explain basic usage of the mybatis-thymeleaf.

=== Installation

==== Maven

If you are using the Maven as build tool, you can add as follow:

[source,xml,subs=""specialchars,attributes""]
.pom.xml (dependencies)
----
<dependencies>
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>{mybatis-version}</version> <!-- Adjust to your application -->
  </dependency>
  <dependency>
    <groupId>org.mybatis.scripting</groupId>
    <artifactId>mybatis-thymeleaf</artifactId>
    <version>{revnumber}</version>
  </dependency>
</dependencies>
----

If you use a snapshot version, you need add the configuration
for using the ""Sonatype OSS Snapshots Repository"" as follow:

[source,xml,subs=""specialchars,attributes""]
.pom.xml (repositories)
----
<repositories>
  <repository>
    <id>sonatype-oss-snapshots</id>
    <name>Sonatype OSS Snapshots Repository</name>
    <url>https://oss.sonatype.org/content/repositories/snapshots</url>
  </repository>
</repositories>
----

==== Gradle

If you are using the Gradle as build tool, you can add as follow:

[source,groovy,subs=""specialchars,attributes""]
.build.gradle (dependencies)
----
dependencies {
  compile(""org.mybatis:mybatis:{mybatis-version}"") // Adjust version to your application
  compile(""org.mybatis.scripting:mybatis-thymeleaf:{revnumber}"")
}
----

If you use a snapshot version, you need add the configuration for using the ""Sonatype OSS Snapshots Repository"" as follow:

[source,groovy,subs=""specialchars,attributes""]
.build.gradle (repositories)
----
repositories {
  maven { url ""https://oss.sonatype.org/content/repositories/snapshots"" }
}
----

=== Configuration

Set the `ThymeleafLanguageDriver` as your default scripting language to MyBatis.

[source,java]
.Configuration class (Java based configuration)
----
Configuration configuration = new Configuration();
configuration.setDefaultScriptingLanguage(ThymeleafLanguageDriver.class);
----

[source,xml]
.mybatis-config.xml (XML based configuration)
----
<settings>
  <setting name=""defaultScriptingLanguage""
           value=""org.mybatis.scripting.thymeleaf.ThymeleafLanguageDriver""/>
</settings>
----

=== Creating Mapper

The MyBatis provides two ways(annotation driven and XML driven) for creating a Mapper.

==== Annotation driven mapper

If you use the annotation driven mapper, you can specify an SQL as follow:

[source,java]
.src/main/java/com/example/NameMapper.java
----
public class NameMapper {
  @Select(""SELECT * FROM names WHERE id = /*[# mb:p='id']*/ 1 /*[/]*/"")
  Name findById(Integer id);
}
----

[TIP]
====
You can specify a readable SQL on annotation using ""Multiline String Literals"" provided by some JVM language.
About ""Multiline String Literals"", please see the <<Multiline String Literals>>.
====


Also, you can specify an SQL on template file(e.g. `NameMapper/findById.sql` on class path) as follow:

[source,java]
----
@Select(""NameMapper/findById.sql"")
Name findById(Integer id);
----

By default behavior, the mybatis-thymeleaf read a specified template file from just under classpath.

[[_getting-started-template-sql]]
[source,sql]
.src/main/resources/NameMapper/findById.sql
----
SELECT * FROM names
  WHERE id = /*[# mb:p=""id""]*/ 1 /*[/]*/
----

[TIP]
====
Since 1.0.1, we support to read a template file from under classpath automatically using the <<TemplateFilePathProvider, TemplateFilePathProvider>>.
====


==== XML driven mapper

If you use the XML driven mapper, you can specify an SQL on mapper XML file as follow:

[source,java]
.src/main/java/com/example/NameMapper.java
----
public class NameMapper {
  Name findById(Integer id);
}
----

[source,xml]
.src/main/resources/com/example/NameMapper.xml
----
<mapper namespace=""com.example..NameMapper"">
  <select id=""findById"" resultType=""com.example.Name"">
    <![CDATA[
    SELECT * FROM names
      WHERE id = /*[# mb:p=""id""]*/ 1 /*[/]*/
    ]]>
  </select>
</mapper>
----

Also, you can specify an SQL on template file
(see '<<_getting-started-template-sql,Annotation driven mapper>>' section) as follow:

[source,xml]
----
<select id=""findById"" resultType=""com.example.Name"">
  NameMapper/findById.sql
</select>
----

== Configuration

In this chapter, we explain a way for applying mybatis-thymeleaf to the MyBatis in detail.
About MyBatis core module configuration,
please see the {mybatis-doc-url}/configuration.html[MyBatis reference document^].

=== Basic configuration

You configure to use the `org.mybatis.scripting.thymeleaf.ThymeleafLanguageDriver` as scripting language driver.

==== Java based configuration

[source,java]
.Configuration class
----
Configuration configuration = new Configuration();
configuration.setDefaultScriptingLanguage(ThymeleafLanguageDriver.class); // <1>
// ...
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);
----

<1> Set the `ThymeleafLanguageDriver` class to a `Configuration` instance as default scripting language driver

==== XML based configuration

[source,xml]
.src/main/resources/mybatis-config.xml
----
<settings>
  <setting name=""defaultScriptingLanguage""
           value=""org.mybatis.scripting.thymeleaf.ThymeleafLanguageDriver""/> // <1>
</settings>
----

[source,java]
----
SqlSessionFactory sqlSessionFactory;
try (Reader configReader = Resources.getResourceAsReader(""mybatis-config.xml"")) {
  sqlSessionFactory = new SqlSessionFactoryBuilder().build(configReader);
}
----

<1> Set the `ThymeleafLanguageDriver` class to the `defaultScriptingLanguage` of setting item in configuration XML file

=== Customizing configuration

The mybatis-thymeleaf provides three ways for customizing template engine configuration.

* <<Using properties file>>
* <<Using functional interface>>
* <<Using user-defined template engine>>

==== Using properties file

The mybatis-thymeleaf provide the special properties file for customizing default configuration.
By default behavior, the mybatis-thymeleaf load the `mybatis-thymeleaf.properties` stored just under classpath.
About supported properties, please see the <<Configuration properties>>.

===== Using an any properties file

You can use an any properties file instead of the default properties file.
If you use an any properties file, please specify a properties file using
the special system properties(`mybatis-thymeleaf.config.file`) as follow:

[source,text]
----
$ java -Dmybatis-thymeleaf.config.file=mybatis-thymeleaf_production.properties ...
----

===== Using an any file encoding

You can use an any file encoding instead of the default file encoding(`UTF-8`).
If you use an any file encoding, please specify a file encoding using
the special system properties(`mybatis-thymeleaf.config.encoding`) as follow:

[source,text]
----
$ java -Dmybatis-thymeleaf.config.encoding=Windows-31J ...
----

==== Using functional interface

The mybatis-thymeleaf provide the special functional
interface(`org.mybatis.scripting.thymeleaf.TemplateEngineCustomizer`) for customizing configurations using Java code.
This feature provide an opportunity to customize configuration that cannot customize it using properties file.

[source,java]
.src/main/java/com/example/MyTemplateEngineCustomizer.java
----
public class MyTemplateEngineCustomizer implements TemplateEngineCustomizer {
  @Override
  public void customize(TemplateEngine defaultTemplateEngine) {
    // ... <1>
  }
}
----

[source,properties]
.src/main/resources/mybatis-thymeleaf.properties
----
customizer = com.example.MyTemplateEngineCustomizer # <2>
----

<1> Write a Java code for customizing template engine

<2> Specify a FQCN of customizer class in `mybatis-thymeleaf.properties`

==== Using user-defined template engine

When your application requirements cannot be satisfied using above customizing features,
you can apply a user-defined template engine(full managed template engine) to the mybatis-thymeleaf as follow:

[source,java]
.Configuration class
----
TemplateEngine templateEngine = new TemplateEngine(); // <1>
templateEngine.addDialect(new MyBatisDialect());
templateEngine.setEngineContextFactory(new MyBatisIntegratingEngineContextFactory(
    templateEngine.getEngineContextFactory()));
// ...

Configuration configuration = new Configuration();
configuration.getLanguageRegistry().register(new ThymeleafLanguageDriver(templateEngine)); // <2>
configuration.setDefaultScriptingLanguage(ThymeleafLanguageDriver.class); // <3>
----

<1> Create an instance of class that implements `org.thymeleaf.ITemplateEngine`

<2> Register an instance of `ThymeleafLanguageDriver` that associate with user-defined template engine instance

<3> Set the `ThymeleafLanguageDriver` class as default scripting language driver

== Writing 2-way SQL

In this section, we explain standard usage of 2-way SQL.

[CAUTION]
====
About cautions for usage 2-way SQL, please see the <<Cautions for usage>>.
====


=== Binding value

The mybatis-thymeleaf use the default binding feature provided by MyBatis core module.
Therefore, you need to write a 2-way SQL template for generating string
that can be parsed by MyBatis core module as follow:

[source,sql]
.About default binding feature provided by MyBatis
----
SELECT * FROM names
  WHERE id = #{id} -- <1>
----

[source,sql]
.SQL template for generating string that can be parsed by MyBatis core module
----
SELECT * FROM names
  WHERE id = /*[# mb:p=""id""]*/ 1 /*[/]*/ -- <2>
----

<1> A bind value is specified by 「`#{variable name}`」 format
<2> Can render bind variable expression that can be parsed by MyBatis core module using custom attribute tag(`mb:p=""variable name""`) provided by mybatis-thymeleaf

[NOTE]
====
**What can you bind?**

Basically, you can bind a parameter object(Mapper method arguments or `SqlSession` method arguments).
In addition, the mybatis-thymeleaf allow to be bind a registered value using `mb:bind` tag.
About usage of `mb:bind`, please see <<Attribute tag>>.
====

=== Dynamic SQL

The Thymeleaf supports to create an any string dynamically using conditional evaluation
and iterating evaluation feature. By using this feature, you can write a dynamic SQL.

* <<Using tag for specifying condition>>
* <<Using tag for iteration>>

==== Using tag for specifying condition

If you add a SQL part when any condition is matches or not, you can use following attribute tags.

* `th:if`
* `th:unless` (denial version for `th:if`)
* `th:switch`
* `th:case`

[source,sql]
.Usage of conditional attribute tag on WHERE
----
SELECT * FROM names
  WHERE 1 = 1 -- <1>
  /*[# th:if=""${firstName} != null""]*/ -- <2>
    AND firstName = /*[# mb:p=""firstName""]*/ 'Taro' /*[/]*/
  /*[/]*/ -- <3>
  ORDER BY id
----

[source,sql]
.Usage of conditional attribute tag on SET
----
UPDATE names
  SET id = id -- <4>
  /*[# th:if=""${firstName} != null""]*/
    , firstName = /*[# mb:p=""firstName""]*/ 'Taro' /*[/]*/
  /*[/]*/
  WHERE id = /*[# mb:p=""id""]*/ 1 /*[/]*/
----

<1> Specify a non-dynamic condition at first position because the mybatis-thymeleaf does not provide
    the trimming feature such as `<where>` of XML based scripting language

<2> Specify a condition on start tag using natural template

<3> Specify an end tag of condition

<4> Specify a non-dynamic updating column at first position because the mybatis-thymeleaf does not provide
    the trimming feature such as `<set>` of XML based scripting language

==== Using tag for iteration

The Thymeleaf supports to process for iteration object(`List` etc..) using `th:each`.

[source,sql]
.Basic usage of iteration tag
----
SELECT * FROM names
  WHERE 1 = 1
  /*[# th:if=""${not #lists.isEmpty(ids)}""]*/
    AND id IN (
    /*[# th:each=""id : ${ids}""]*/ -- <1>
      /*[# mb:p=""id""]*/ 1 /*[/]*/ -- <2>
      /*[(${idStat.last} ? '' : ',')]*/ -- <3>
    /*[/]*/ -- <4>
    )
  /*[/]*/
  ORDER BY id
----

<1> Specify an iterable object on `th:each`

<2> Specify a SQL template of binding value per iterable element.
    A bind value specify by `mb:p=""{variable name of iterable element}""` format (e.g. `id`).

<3> Append comma character when element position is not last.
    You can access an iteration status object (`IterationStatusVar`) that named by `""{variable name of iterable element}Stat""` format (e.g. `idStat`).

<4> Specify an end tag of iteration

[TIP]
====
An above SQL template can be replaced using `mb:p` attribute tag with following SQL template.


[source,sql]
.Use mb:p for creating bind variables string of IN clause
----
SELECT * FROM names
  WHERE 1 = 1
  /*[# th:if=""${not #lists.isEmpty(ids)}""]*/
    AND id IN (/*[# mb:p=""ids""]*/ 1 /*[/]*/)
  /*[/]*/
  ORDER BY id
----

Since 1.0.2, We support the indexed access using an iteration status object as follow:

[source,sql]
.Use indexed access using an iteration status object
----
SELECT * FROM names
  WHERE 1 = 1
  /*[# th:if=""${not #lists.isEmpty(ids)}""]*/
    AND id IN (
    /*[# th:each=""id : ${ids}""]*/
      /*[# mb:p=""ids[${idStat.index}]""]*/ 1 /*[/]*/ -- <1>
      /*[(${idStat.last} ? '' : ',')]*/
    /*[/]*/
    )
  /*[/]*/
  ORDER BY id
----

<1> Access to a iterable object using indexed

====

About more advanced usage of `th:each` , please see <<Bulk insert>>.

=== Fragment

The Thymeleaf supports to insert template string from an another template file.
By using this feature, you can share an SQL on multiple SQL template.

The standard use case using this feature is paging query as follow:

[source,java]
.Mapper interface
----
// Count a total record number that matches for criteria
@Select(""NameMapper/countByCriteria.sql"")
long countByCriteria(@Param(""criteria"") NameCriteria criteria);

// Search records that matches for criteria and specified page
@Select(""NameMapper/findPageByCriteria.sql"")
List<Name> findPageByCriteria(@Param(""criteria"") NameCriteria criteria, @Param(""pageable"") Pageable pageable);
----

.src/main/resources/NameMapper/countByCriteria.sql
[source,sql]
----
SELECT COUNT(*) FROM names
  WHERE 1 = 1
  /*[# th:if=""${criteria.firstName} != null""]*/
    AND firstName = /*[# mb:p=""criteria.firstName""]*/ 'Taro' /*[/]*/
  /*[/]*/
  /*[# th:if=""${criteria.lastName} != null""]*/
    AND lastName = /*[# mb:p=""criteria.lastName""]*/ 'Yamada' /*[/]*/
  /*[/]*/
----

.src/main/resources/NameMapper/findPageByCriteria.sql
[source,sql]
----
SELECT * FROM names
  WHERE 1 = 1
  /*[# th:if=""${criteria.firstName} != null""]*/
    AND firstName = /*[# mb:p=""criteria.firstName""]*/ 'Taro' /*[/]*/
  /*[/]*/
  /*[# th:if=""${criteria.lastName} != null""]*/
    AND lastName = /*[# mb:p=""criteria.lastName""]*/ 'Yamada' /*[/]*/
  /*[/]*/
  LIMIT /*[# mb:p=""pageable.pageSize""]*/ 20 /*[/]*/
  OFFSET /*[# mb:p=""pageable.offset""]*/ 0 /*[/]*/
  ORDER BY id
----

Probably looking at above SQLs many developers will look for a way to share the `WHERE` clause.
In such case, you can share any SQL part by multiple SQL using fragment feature.

==== Creating a fragment SQL

At first, you create a fragment SQL template file for sharing by multiple SQL as follow:

.src/main/resources/NameMapper/whereByCriteria.sql
[source,sql]
----
/*[- */ -- <1>
SELECT * FROM names
/* -]*/ -- <2>
  WHERE 1 = 1
  /*[# th:if=""${criteria.firstName} != null""]*/
    AND firstName = /*[# mb:p=""criteria.firstName""]*/ 'Taro' /*[/]*/
  /*[/]*/
  /*[# th:if=""${criteria.lastName} != null""]*/
    AND lastName = /*[# mb:p=""criteria.lastName""]*/ 'Yamada' /*[/]*/
  /*[/]*/
----

<1> Start a block comment for ignoring `""SELECT * FROM names""` part at template processing time
<2> End a block comment

==== Insert a fragment SQL

You can insert a fragment SQL template file on each template as follow:

.src/main/resources/NameMapper/countByCriteria.sql
[source,sql]
----
SELECT COUNT(*) FROM names
  /*[# th:insert=""~{NameMapper/whereByCriteria.sql}"" /]*/ -- <1>
----

.src/main/resources/NameMapper/findPageByCriteria.sql
[source,sql]
----
SELECT * FROM names
  /*[# th:insert=""~{NameMapper/whereByCriteria.sql}"" /]*/ -- <1>
  LIMIT /*[# mb:p=""pageable.pageSize""]*/ 20 /*[/]*/
  OFFSET /*[# mb:p=""pageable.offset""]*/ 0 /*[/]*/
  ORDER BY id
----

<1> Insert a fragment SQL template file

=== Special variables

The MyBatis core module provides special variables that prefixed with `_` as follows:

[cols=""2,7,1"",options=""header""]
.Special variables
|===
^|Variable Name
^|Description
^|Type

|`_parameter`
|The parameter object that passed to the MyBatis
|Any type

|`_databaseId`
|The id for identifying the database on current session
(If you want to this variable, you should be enabled the link:{mybatis-doc-url}/configuration.html#databaseIdProvider[`DatabaseIdProvider` feature^] on MyBatis)
|`String`
|===

=== Using configuration properties

You can access the configuration properties of MyBatis from your SQL template.
About configuration properties, please see the link:{mybatis-doc-url}/configuration.html#properties[MyBatis reference documentation^].

[source,java]
.How to set configuration properties using Java based configuration
----
Configuration configuration = new Configuration();
Properties variables = new Properties();
variables.setProperty(""tableNameOfUser"", ""accounts""); // <1>
configuration.setVariables(variables);
----

[source,xml]
.How to set configuration properties using XML based configuration (mybatis-config.xml)
----
<properties>
  <property name=""tableNameOfUser"" value=""accounts""/> <!--1-->
</properties>
----

[source,sql]
.SQL template
----
SELECT * FROM /*[# th:utext=""${tableNameOfUser} ?: 'users'""]*/ users /*[/]*/ -- <2>
----

<1> Define an any property as MyBatis's configuration properties
<2> Access a configuration property using Thymeleaf's expression

Above SQL template translate to as follows:

[source,sql]
.Translated SQL (when tableNameOfUser is defined)
----
SELECT * FROM accounts
----

[source,sql]
.Translated SQL (when tableNameOfUser is not defined)
----
SELECT * FROM users
----

== Using non 2-way SQL mode

The non 2-way SQL is simple a little compare with 2-way SQL and limitations not found at now.

=== Configuration

By default, the mybatis-thymeleaf will be use the 2-way SQL mode.
Therefore you should be configure explicitly to use the non 2-way SQL mode using configuration properties file or builder option as follow:

[NOTE]
====
This configuration is optional. The non 2-way SQL can be use on the 2-way SQL mode.
====

[source,properties]
.How to configure using configuration properties file(src/main/resources/mybatis-thymeleaf.properties)
----
use2way = false # <1>
----

<1> Set the `use2way` to `false`

[source,java]
.How to configure using config class
----
configuration.getLanguageRegistry().register(new ThymeleafLanguageDriver(
        ThymeleafLanguageDriverConfig.newInstance(c -> c.setUse2Way(false)))); // <1>
----

<1> Set the `use2way` property of `ThymeleafLanguageDriverConfig` to `false`


=== Basic usage

The different with the 2-way SQL mode is that will be unnecessary to enclose the thymeleaf expressions as SQL comment(`/\\*[...]*/`).

[source,sql]
.SQL Template
----
SELECT * FROM names
  WHERE 1 = 1
  [# th:if=""${not #lists.isEmpty(ids)}""]
    AND id IN (
      [# mb:p=""ids"" /]
    )
  [/]
  ORDER BY id
----

== Custom Dialect

The mybatis-thymeleaf provide the custom dialect class(`org.mybatis.scripting.thymeleaf.MyBatisDialect`)
that help for generating SQL template.

=== Attribute tag

The mybatis-thymeleaf provides following attribute tags.
By default, you can use it using `mb` dialect prefix (default prefix is initial letter of ""**M**y**B**atis"").

[cols=""2,4,4"",options=""header""]
.Supported method list
|===
^|Attribute Tag Name
^|Description
^|Attribute Value Format

|<<mybatis-param,p>>
a|Render bind variable(default format: `#{...}`) that can be parsed by MyBatis core module and register an iteration object to the MyBatis's bind variables. +
 +
 The bind variable format decide by a implementation of `BindVariableRender`.
a|`{variableName}(,{optionKey}={optionValue},...)` +
 +
 Valid format is same with link:{mybatis-doc-url}/sqlmap-xml.html#Parameters[MyBatis's inline parameter format^].

|<<mybatis-bind,bind>>
|Register an any value to the MyBatis's bind variables
(Provides a feature similar to that of the link:{mybatis-doc-url}/dynamic-sql.html#bind[`<bind>`^] provided by MyBatis core module)
a|`{variable name}={variable value}(,...)` +
 +
 Valid format is same with `th:with` provided by Thymeleaf.
|===

[[mybatis-param]]
==== p

[source,sql]
.Basic usage:
----
SELECT * FROM names
  WHERE id = /*[# mb:p=""id""]*/ 1 /*[/]*/ -- <1>
----

[source,sql]
.Usage with option:
----
SELECT * FROM names
  WHERE id = /*[# mb:p=""id,typeHandler=com.example.IdTypeHandler""]*/ 1 /*[/]*/ -- <2>
----

[source,sql]
.Usage for collection and array:
----
SELECT * FROM names
  WHERE id IN (/*[# mb:p=""ids""]*/ 1 /*[/]*/) -- <3>
----

<1> Render single bind variable(e.g. `#{id}`) that can be parsed by MyBatis core module when specify a simple value object
<2> Can specify parameter options(`key=value` format) separate with comma
<3> Render multiple bind variables(e.g. `#{ids[0]}, #{ids[1]}, ...`) that can be parsed by MyBatis core module when specify a collection or array object


[[mybatis-bind]]
==== bind

[source,sql]
.Basic usage:
----
SELECT * FROM names
  WHERE 1 = 1
  /*[# th:if=""${firstName} != null""]*/
    /*[# mb:bind=""patternFirstName=|${#likes.escapeWildcard(firstName)}%|"" /]*/ -- <1>
    AND firstName LIKE /*[# mb:p=""patternFirstName""]*/ 'Taro' /*[/]*/ -- <2>
  /*[/]*/
----

[source,sql]
.Usage for registering multiple variables:
----
/*[# mb:bind=""patternFirstName=|${#likes.escapeWildcard(firstName)}%|, patternLastName=|${#likes.escapeWildcard(lastName)}%|"" /]*/ -- <3>
----

<1> Register an any value(e.g. editing value at template) as custom bind variables
<2> Bind a custom bind variable
<3> Also, you can register multiple custom bind variables separating with comma at the same time

[NOTE]
====
*Why need the bind tag?*

The binding feature provide by MyBatis cannot access a variable that shared by the `th:with`
because it can only access within a template. Hence, the mybatis-thymeleaf provide the `bind` attribute tag.
====

=== Expression utility method

==== #likes expression

The `#likes` expression provide utility methods for LIKE clause.

[cols=""1,5a,4"",options=""header""]
.Supported method list
|===
^|Method
^|Arguments
^|Description

|<<mybatis-escapeLikeWildcard,escapeWildcard>>
|

[cols=""^1,4,5"",options=""header""]
!===
^!No
^!Type
^!Description

!1
!String
!A target value
!===

|Return a value that escaped a wildcard character of LIKE condition.
By default behavior, this method escape the `""%""`, `""_""` and `""\\""`(escape character itself) using `""\\""`.

|<<mybatis-likeEscapeClause,escapeClause>>
| None
|Return a escape clause string of LIKE condition.
By default behavior, this method return `""ESCAPE '\\'""`.
|===


[TIP]
====
You can customize the default behavior for the `escapeWildcard` and `escapeClause`
using <<Configuration properties, Configuration properties>>.
====


[[mybatis-escapeLikeWildcard]]
===== escapeWildcard

[source,sql]
.Basic usage:
----
/*[# th:if=""${firstName} != null""]*/
  /*[# mb:bind=""patternFirstName=|${#likes.escapeWildcard(firstName)}%|"" /]*/ -- <1>
  AND firstName LIKE /*[# mb:p=""patternFirstName""]*/ 'Taro%' /*[/]*/
/*[/]*/
----

<1> Register a value that escaped wildcard character of LIKE condition as custom bind variables

[source,sql]
.Translate to:
----
  AND firstName LIKE #{patternFirstName}
----


[[mybatis-likeEscapeClause]]
===== escapeClause

[source,sql]
.Basic usage:
----
/*[# th:if=""${firstName} != null""]*/
  /*[# mb:bind=""patternFirstName=|${#likes.escapeWildcard(firstName)}%|"" /]*/
  AND firstName LIKE /*[# mb:p=""patternFirstName""]*/ 'Taro%' /*[/]*/ /*[(${#likes.escapeClause()})]*/ -- <1>
/*[/]*/
----

<1> Add `ESCAPE` clause at template processing time

[source,sql]
.Translate to:
----
  AND firstName LIKE #{patternFirstName} ESCAPE '\\'
----

== Using SQL Generator

Since 1.0.2, we separate the SQL generating feature from the `ThymeleafLanguageDriver` and `ThymeleafSqlSource` class,
we added the `SqlGenerator` and `SqlGeneratorConfig` for generating SQL from SQL template.
These classes **does not depends on the MyBatis core module**(`mybatis-3.x.x.jar`).
So that, it also can be used in combination with any data access libraries(e.g. Spring JDBC, JPA, R2DBC, etc...) that provide with named parameter.

=== Configuration

By default, the `SqlGenerator` applies settings for using together with the MyBatis core module(apply to `#{...}` as the bind variable format),
but you can customize a default settings using configuration properties file or the `SqlGeneratorConfig`.
The `SqlGeneratorConfig` allows the same configurations as the `ThymeleafLanguageDriverConfig` except the `TemplateFilePathProvider`(`template-file.path-provider.*`).

==== Customize the bind variable format

You can customize the bind variable format using configuration properties file or configuration class.
In the following example, it changes the bind variable format to the Spring JDBC format(e.g. `:id`) from MyBatis core format(e.g. `#{id}`).

[source,properties]
.How to customize using configuration properties file
----
dialect.bind-variable-render = org.mybatis.scripting.thymeleaf.support.spring.SpringNamedParameterBindVariableRender # <1>
----

<1> Specify the `BindVariableRender` implementation class(built-in class) that render Spring JDBC bind variable format


[source,java]
.How to customize using config class
----
SqlGeneratorConfig config = SqlGeneratorConfig.newInstanceWithCustomizer(c ->
    c.getDialect().setBindVariableRender(
        BindVariableRender.BuiltIn.SPRING_NAMED_PARAMETER.getType())); // <1>
SqlGenerator sqlGenerator = new SqlGenerator(config); // <2>
----

<1> Specify the `BindVariableRender` implementation class(built-in class) that render Spring JDBC bind variable format via `BuiltIn` enum
<2> Create a `SqlGenerator` instance with user defined configuration

If you use the custom bind variable format other than built-in format,
please create a implementation class of `BindVariableRender` and apply it to the configuration.

[source,java]
.How to create the BindVariableRender implementation class
----
public class R2dbcMySQLBindVariableRender implements BindVariableRender { // <1>
  public String render(String name) {
    return ""?"" + name;
  }
}
----

<1> Create a `BindVariableRender` implementation class


==== Customize other configurations

Please see also the following sections.

* <<Configuration properties>>


=== Basic Usage

The `SqlGenerator` provide feature for generating a SQL from SQL template using the Thymeleaf as follow:

[source,java]
.Basic Usage:
----
SqlGenerator sqlGenerator = new SqlGenerator(); // <1>

Conditions conditions = new Conditions();
conditions.setId(10);

// sql = ""SELECT * FROM accounts WHERE id = #{id}""
String sql = sqlGenerator.generate(
    ""SELECT * FROM accounts WHERE id = /*[# mb:p='id']*/ 1 /*[/]*/"", conditions); // <2>
----

<1> Create a default instance of `SqlGenerator`
<2> Generate an SQL from SQL template

[NOTE]
====
The `SqlGenerator#generate` method is **thread-safe**. In other words, you can share an `SqlGenerator` instance at any components.
====

==== Receiving generated bind variables

You can receiving bind variables that generated during template processing via a `BiConsumer` function as follow:

[NOTE]
====
The bind variables may generate when use `mb:bind` or `mb:p` tag.
====

[source,java]
.How to receive bind variables using binder function:
----
SqlGenerator sqlGenerator = new SqlGenerator();

Map<String, Object> conditionsMap = new HashMap<>();
conditionsMap.put(""name"", ""Yamada"");

// sql = ""SELECT * FROM accounts WHERE name = #{patternName}""
// conditionsMap = {""name"":""Yamada"", ""patternName"":""Yamada%""}
String sql = sqlGenerator.generate(
    ""/*[# mb:bind='patternName=|${#likes.escapeWildcard(name)}%|' /]*/"" +
    ""SELECT * FROM accounts WHERE name = /*[# mb:p='patternName']*/ 'Sato' /*[/]*/"",
    conditionsMap, conditionsMap::put); // <1>
----

<1> Specify(Pass) a `BiConsumer` function for receiving bind variables at 3th argument of `generate` method


==== Specifying custom variables

You can specify any custom variables separately from the parameter object as follow:

[source,java]
.How to use custom variables:
----
SqlGenerator sqlGenerator = new SqlGenerator();
sqlGenerator.setDefaultCustomVariables(
    Collections.singletonMap(""accountsTableName"", ""users"")); // <1>

Account account = new Account();
account.setName(""Taro Yamada"");

Map<String, Object> customVariables = new HashMap<>(); // <2>
customVariables.put(""now"", LocalDateTime.now());
customVariables.put(""loginId"", loginId);

// sql = ""INSERT INTO users (name, created_at, created_by) VALUES(#{name}, #{now}, #{loginId})""
String sql = sqlGenerator.generate(
    ""INSERT INTO /*[# th:utext=\\""${accountsTableName} ?: 'accounts'\\""]*/ accounts /*[/]*/ "" + // <3>
      ""(name, created_at, created_by) VALUES("" +
        ""/*[# mb:p='name']*/ 'Hanako Yamada' /*[/]*/, "" +
        ""/*[# mb:p='now']*/ current_timestamp() /*[/]*/, "" + // <4>
        ""/*[# mb:p='loginId']*/ 'A00000001' /*[/]*/"" + // <4>
      "")"", account, customVariables); // <5>
----

<1> Specify the default custom variable for sharing by every statements
<2> Create custom variables per statement or transaction
<3> Can be access to a custom variable at template processing time
<4> Can be bind a custom variable
<5> Specify(Pass) custom variables map to sql generator at 3rd argument of `generate` method

=== Advanced Usage

==== Access JavaBeans property

By default, the `SqlGenerator` use the JDK standard APIs(JavaBeans and Reflection API) for accessing a property of user defined Java object.
If there is a conflict with property accessing in the data access library,
you can change a default behavior by applying a custom `org.mybatis.scripting.thymeleaf.PropertyAccessor` implementation class.

[source,java]
.How to apply a custom PropertyAccessor
----
SqlGenerator sqlGenerator = new SqlGenerator();
sqlGenerator.setPropertyAccessor(new MyPropertyAccessor()); // <1>
----

<1> Set a custom `PropertyAccessor` implementation class to the `SqlGenerator`


== Support classes

We provides useful classes for supporting development.

=== TemplateFilePathProvider

The `org.mybatis.scripting.thymeleaf.support.TemplateFilePathProvider` is SQL provider class that return the SQL template file path. This class is available since 1.0.1.
This class use with SQL provider annotation(`@InsertProvider`, `@UpdateProvider`, `@DeleteProvider` and `@SelectProvider`) as follow:

[NOTE]
====
**This class required to use on MyBatis 3.5.1+.**
====

.Usage:

[source, java]
----
package com.example.mapper;

public interface BaseMapper<T> {

  @Options(useGeneratedKeys = true, keyProperty = ""id"")
  @InsertProvider(type = TemplateFilePathProvider.class)
  void insert(T entity);

  @UpdateProvider(type = TemplateFilePathProvider.class)
  void update(T entity);

  @DeleteProvider(type = TemplateFilePathProvider.class)
  void delete(T entity);

  @SelectProvider(type = TemplateFilePathProvider.class)
  T findById(Integer id);

}
----

[source, java]
----
package com.example.mapper;

public interface NameMapper extends BaseMapper {

  @SelectProvider(type = TemplateFilePathProvider.class)
  List<Name> findByCondition(NameCondition condition);

}
----

[TIP]
====
Since the MyBatis 3.5.6, you can omit the `type` attribute at each annotations
when specify the default provider class as global configuration as follow:

.Mapper interface
[source, java]
----
public interface NameMapper extends BaseMapper {
  @SelectProvider
  List<Name> findByCondition(NameCondition condition);
}
----

.Java based configuration
[source, java]
----
Configuration configuration = new Configuration();
configuration.setDefaultSqlProviderType(TemplateFilePathProvider.class);
----

.XML based configuration
[source, xml]
----
<settings>
  <setting name=""defaultSqlProviderType"" value=""org.mybatis.scripting.thymeleaf.support.TemplateFilePathProvider""/>
</settings>
----

====

By default implementation, a template file path resolve following format and priority order.
If does not match all, it throw an exception that indicate not found a template file.

* `com/example/mapper/NameMapper/NameMapper-{methodName}-{databaseId}.sql`
* `com/example/mapper/NameMapper/NameMapper-{methodName}.sql` +
  (fallback using default database)
* `com/example/mapper/BaseMapper/BaseMapper-{methodName}-{databaseId}.sql` +
  (fallback using declaring class of mapper method)
* `com/example/mapper/BaseMapper/BaseMapper-{methodName}.sql` +
  (fallback using declaring class of mapper method and default database)

If you want to customize the template file path format,
you can customize using the <<Configuration properties, configuration properties>> that start with `template-file.path-provider`.

=== SpringNamedParameterBindVariableRender

The `org.mybatis.scripting.thymeleaf.support.spring.SpringNamedParameterBindVariableRender` is the `BindVariableRender`
implementation class for rendering bind variable to 「`:variable name`」 format(e.g. `:id`). This class is available since 1.0.2.

[source,properties]
.How to enable via configuration properties file (mybatis-thymeleaf.properties)
----
dialect.bind-variable-render = org.mybatis.scripting.thymeleaf.support.spring.SpringNamedParameterBindVariableRender
----

[source,java]
.How to enable via configuration class (SqlGeneratorConfig)
----
SqlGeneratorConfig config = SqlGeneratorConfig.newInstanceWithCustomizer(c ->
    c.getDialect().setBindVariableRender(
        BindVariableRender.BuiltIn.SPRING_NAMED_PARAMETER.getType()));
SqlGenerator sqlGenerator = new SqlGenerator(config);
----


== Cautions for usage

[CAUTION]
====
The Thymeleaf 3 does not provide the template mode for SQL.
Therefore there are some cautions for usage.
====

=== Using '\\'(backslash)

If you are using 2-way SQL mode, there is case that cannot parse a 2-way SQL when specify `'\\'`(backslash) within static template parts.
We know that following case cannot be parsed 2-way SQL. If you are not using 2-way SQL mode, this limitation can be ignore.

==== ESCAPE clause for LIKE

If you specify the `ESCAPE '\\'` directly as static template parts, the Thymeleaf cannot parse it.

[source,sql]
.Invalid usage
----
/*[# mb:bind=""patternFirstName=|${#likes.escapeWildcard(firstName)}%|"" /]*/
AND firstName LIKE /*[('#{patternFirstName}')]*/ 'Taro%' /**/ ESCAPE '\\' --<1>
----

<1> Specify the `ESCAPE '\\'` directly as static template parts

[TIP]
====
As a solution for avoiding this behavior,
the mybatis-thymeleaf provide the expression utility method for adding the `ESCAPE` clause.
For detail, please see <<escapeClause>>.
====

=== Using #likes.escapeClause()

You should use the `#likes.escapeClause()` when specify escape character for LIKE phrase,
but you notice there is possible that will be removed characters after `/\\*[(${#likes.escapeClause()})]*/` (link:https://github.com/mybatis/thymeleaf-scripting/issues/66[see gh-66]]).

[source,sql]
.Invalid usage
----
SELECT * FROM area WHERE NAME LIKE 'Tara%' /*[(${#likes.escapeClause()})]*/ ORDER BY ID --<1>
----

<1> Specify any sql phrase after `/\\*[(${#likes.escapeClause()})]*/` without line break

The above sql template will translate to follow(removed `ORDER BY ID`):

[source,sql]
.Translated SQL
----
SELECT * FROM area WHERE NAME LIKE 'Tara%' escape '\\'
----

==== Workarounds

This behavior can be avoided to apply following workarounds.

===== Adding line break character

Add line break character after `/\\*[(${#likes.escapeClause()})]*/`.

[source,sql]
.Valid usage
----
SELECT * FROM area
WHERE NAME LIKE 'Tara%' /*[(${#likes.escapeClause()})]*/
ORDER BY ID
----

===== Adding /**/

Add `/\\**/` after `/*[(${#likes.escapeClause()})]*/`.

[source,sql]
.Valid usage
----
SELECT * FROM area WHERE NAME LIKE 'Tara%' /*[(${#likes.escapeClause()})]*//**/ ORDER BY ID
----

The above sql template will translate to follow:

[source,sql]
.Translated SQL
----
SELECT * FROM area WHERE NAME LIKE 'Tara%' ESCAPE '\\'/**/ ORDER BY ID
----

== Appendix

=== Configuration properties

The mybatis-thymeleaf provides following properties for customizing configurations.

[cols=""3,4,^1,2"",options=""header""]
.Supported property list
|===
^|Property Key
^|Description
^|Type
^|Default value

4+|*General configuration*

|`use2way`
|Whether use the 2-way SQL feature
|`Boolean`
|`true` (enable the 2-way SQL feature)

|`customizer`
|The FQCN of class that implements the `TemplateEngineCustomizer`
(interface for customizing a default TemplateEngine instanced by the mybatis-thymeleaf)
|`Class`
|`null` (This instance is do-nothing)

4+|*Template file configuration*


|`template-file.cache-enabled`
|Whether use the cache feature when load template resource file
|`Boolean`
|`true` (enable template cache feature)

|`template-file.cache-ttl`
|The cache TTL(millisecond) for resolved templates
|`Long`
|`null` (no TTL)

|`template-file.encoding`
|The character encoding for reading template resource file
|`String`
|`""UTF-8""`

|`template-file.base-dir`
|The base directory for reading template resource file
|`String`
|`""""` (just under class path)

|`template-file.patterns`
|The patterns for reading as template resource file
(Can specify multiple patterns using comma(`"",""`) as separator character)
|`String[]`
|`""*.sql""`

4+|*Template file path provider configuration for TemplateFilePathProvider* +
(Available only at `ThymeleafLanguageDriverConfig`)

|`template-file.path-provider.prefix`
|The prefix for adding to template file path
|`String`
|`""""`

|`template-file.path-provider.includes-package-path`
|Whether includes package path part
|`Boolean`
|`true` (includes package path)

|`template-file.path-provider.separate-directory-per-mapper`
|Whether separate directory per mapper
|`Boolean`
|`true` (separate directory per mapper)

|`template-file.path-provider.includes-mapper-name-when-separate-directory`
|Whether includes mapper name into file name when separate directory per mapper
|`Boolean`
|`true` (includes mapper name)

|`template-file.path-provider.cache-enabled`
|Whether cache a resolved template file path
|`Boolean`
|`true` (cache a resolved template file path)

4+|*Dialect configuration*

|`dialect.prefix`
|The prefix name of dialect provided by this project
|`String`
|`""mb""`

|`dialect.like-escape-char`
|The escape character for wildcard of LIKE condition
|`Character`
|`'\\'` (backslash)

|`dialect.like-escape-clause-format`
|The format of escape clause for LIKE condition
(Can specify format that can be allowed by `String#format` method)
|`String`
|`""ESCAPE '%s'""`

|`dialect.like-additional-escape-target-chars`
|Additional escape target characters(custom wildcard characters) for LIKE condition
(Can specify multiple characters using comma(`"",""`) as separator character)
|`Character[]`
|`""""` (no specify)

|`dialect.bind-variable-render`
|The FQCN of class that implements the `BindVariableRender`
(interface for rendering a bind variable such as `#{id}`, `:id`, etc...)
|`Class`
|`null` (Uses render class for MyBatis)
|===

[source,properties]
.src/main/resources/mybatis-thymeleaf.properties
----
use2way = false
customizer = com.example.MyTemplateEngineCustomizer
template-file.cache-enabled = true
template-file.cache-ttl = 3600000
template-file.encoding = UTF-8
template-file.base-dir = templates/
template-file.patterns = *sql, *.sql.template
template-file.path-provider.prefix = sqls/
template-file.path-provider.includes-package-path = false
template-file.path-provider.separate-directory-per-mapper = false
template-file.path-provider.includes-mapper-name-when-separate-directory = false
dialect.prefix = mybatis
dialect.like-escape-char = ~
dialect.like-escape-clause-format = escape '%s'
dialect.like-additional-escape-target-chars = ％, ＿
dialect.bind-variable-render = org.mybatis.scripting.thymeleaf.support.spring.SpringNamedParameterBindVariableRender
----

[TIP]
====
These properties can be specified via factory method of `ThymeleafLanguageDriverConfig` as follow:

[source,java]
----
configuration.getLanguageRegistry().register(
  new ThymeleafLanguageDriver(ThymeleafLanguageDriverConfig.newInstance(c -> {
  c.setUse2way(false);
  c.setCustomizer(CustomTemplateEngineCustomizer.class);
  c.getTemplateFile().setCacheEnabled(false);
  c.getTemplateFile().setCacheTtl(3600000L);
  c.getTemplateFile().setEncoding(StandardCharsets.UTF_8);
  c.getTemplateFile().setBaseDir(""templates/"");
  c.getTemplateFile().setPatterns(""*.sql"", ""*.sql.template"");
  c.getTemplateFile().getPathProvider().setPrefix(""sqls/"");
  c.getTemplateFile().getPathProvider().setIncludesPackagePath(false);
  c.getTemplateFile().getPathProvider().setSeparateDirectoryPerMapper(false);
  c.getTemplateFile().getPathProvider()
      .setIncludesMapperNameWhenSeparateDirectory(false);
  c.getDialect().setPrefix(""mybatis"");
  c.getDialect().setLikeEscapeChar('~');
  c.getDialect().setLikeEscapeClauseFormat(""escape '%s'"");
  c.getDialect().setLikeAdditionalEscapeTargetChars('％', '＿');
  c.getDialect().setBindVariableRender(
      BindVariableRender.BuiltIn.SPRING_NAMED_PARAMETER.getType());
})));
----

If you specify the value both with properties file and customizer function, the properties file value applied.
We provide following factory methods for creating a `ThymeleafLanguageDriver` instance.

* `newInstance()`
* `newInstance(String resourcePath)`
* `newInstance(Properties customProperties)`
* `newInstance(Consumer<ThymeleafLanguageDriverConfig> customizer)`

These properties can be specified via factory method of `SqlGeneratorConfig` as follow:

[source,java]
----
SqlGeneratorConfig config =
  SqlGeneratorConfig.newInstanceWithCustomizer(c -> {
  c.setUse2way(false);
  c.setCustomizer(CustomTemplateEngineCustomizer.class);
  c.getTemplateFile().setCacheEnabled(false);
  c.getTemplateFile().setCacheTtl(3600000L);
  c.getTemplateFile().setEncoding(StandardCharsets.UTF_8);
  c.getTemplateFile().setBaseDir(""templates/"");
  c.getTemplateFile().setPatterns(""*.sql"", ""*.sql.template"");
  c.getDialect().setPrefix(""mybatis"");
  c.getDialect().setLikeEscapeChar('~');
  c.getDialect().setLikeEscapeClauseFormat(""escape '%s'"");
  c.getDialect().setLikeAdditionalEscapeTargetChars('％', '＿');
  c.getDialect().setBindVariableRender(
      BindVariableRender.BuiltIn.SPRING_NAMED_PARAMETER.getType());
});
// ...
----

We provide following factory methods for creating a `SqlGeneratorConfig` instance.

* `newInstance()`
* `newInstanceWithResourcePath(String resourcePath)`
* `newInstanceWithProperties(Properties customProperties)`
* `newInstanceWithCustomizer(Consumer<SqlGeneratorConfig> customizer)`

====


=== Bulk insert

This section describe about bulk insert for collection or array using SQL rather than JDBC feature.
If you want to insert a collection or array by bulk, you can be realized it using the `th:each` and `mb:p` attribute tags as follow:


[source,java]
.Domain objects
----
public class Person {
  private int id;
  private String firstName;
  private String lastName;
  private LocalDate dateOfBirth;
  private List<Mail> mails;
  // ...
}
public class Mail {
  private int id;
  private int personId;
  private String address;
  // ...
}
----

[source,java]
.Mapper methods
----
@Options(useGeneratedKeys = true, keyProperty = ""id"")
@Insert(""sqls/PersonMapper_insertByBulk.sql"")
void insertByBulk(List<Person> persons);

@Insert(""sqls/PersonMapper_insertMailsByBulk.sql"")
void insertMailsByBulk(List<Person> persons);
----

[source,sql]
.SQL template for top level collection/array
----
INSERT INTO persons
  (first_name, last_name, date_of_birth)
VALUES
/*[# th:each=""person : ${list}""]*/ -- <1>
  (
    /*[# mb:p=""person.firstName""]*/ 'Taro' /*[/]*/, -- <2>
    /*[# mb:p=""person.lastName""]*/ 'Yamada' /*[/]*/,
    /*[# mb:p=""person.dateOfBirth""]*/ '2000-03-28' /*[/]*/
  )/*[(${personStat.last} ? '' : ',')]*/
/*[/]*/
----

[source,sql]
.SQL template for nested property collection/array
----
INSERT INTO person_mails
  (person_id, address)
VALUES
/*[# th:each=""person : ${list}""]*/ -- <1>
  /*[# th:each=""mail : ${person.mails}""]*/ -- <3>
    (
      /*[# mb:p=""person.id""]*/ 1 /*[/]*/,
      /*[# mb:p=""mail.address""]*/ 'taro.yamada@mybatis.org' /*[/]*/ -- <4>
    )/*[(${personStat.last and mailStat.last} ? '' : ',')]*/
  /*[/]*/
/*[/]*/
----

<1> Fetch and store to local variable(e.g. `person`) an element object of top level collection/array using `th:each`
<2> Specify a property of element object fetched from top level collection/array as bind variable using `mb:p`
<3> Fetch and store to local variable(e.g. `mail`) and element object of nested property collection or array
<4> Specify a property of element object fetched from nested property collection/array as bind variable using `mb:p`

The `mb:p` register an element object that fetched from collection/array to the MyBatis’s bind variables.


=== Multiline String Literals

You can specify an SQL in annotation using ""link:https://openjdk.java.net/jeps/355[Text Blocks^]"" feature that support since the JDK 13.
Also,""Multiline String Literals"" provided other JVM languages (such as Kotlin and Groovy) can be used.
There is a good compatibility with annotation driven mapper.

==== Java

* link:https://openjdk.java.net/jeps/355[Text Blocks^]

[source,java]
----
@Select(""""""
  SELECT * FROM names
    WHERE id = /*[# mb:p=""id""]*/ 1 /*[/]*/
"""""")
Name findById(Integer id);
----

==== Kotlin

* link:https://kotlinlang.org/docs/reference/basic-types.html#string-literals[String Literals^]

[source,kotlin]
.Kotlin
----
@Select(""""""
  SELECT * FROM names
    WHERE id = /*[# mb:p=""id""]*/ 1 /*[/]*/
"""""")
fun findById(id: Int): Name
----

==== Groovy

* link:http://docs.groovy-lang.org/latest/html/documentation/#_triple_single_quoted_string[Triple single quoted string^]

[source,groovy]
.Groovy
----
@Select('''
  SELECT * FROM names
    WHERE id = /*[# mb:p=""id""]*/ 1 /*[/]*/
''')
Name findById(int id);
----

=== Related resources


[cols=""2,8"",options=""header""]
.Related resource list
|===
^|Resource name
^|Description

|link:{github-url}[GiHub Page^]
|The mybatis-thymeleaf GiHub top page

|link:{github-wiki-url}/Usage-on-framework[Usage on framework^]
|Explain how to integrate with an application framework

|link:{github-wiki-url}/Code-completion[Code completion^]
|Explain about code completion

|link:{github-wiki-url}/Quick-Start[Quick Start^]
|Explain how to use mybatis-thymeleaf quickly using the Spring Boot
|===

",12471,False,2222.3550588271987,median
"#include ""cpudefs.h""
void op_d000(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	BYTE src = m68k_regs.d[srcreg].B.l;
{	BYTE dst = m68k_regs.d[dstreg].B.l;
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	ZFLG = ((BYTE)(newv)) == 0;
	m68k_regs.d[dstreg].B.l = newv;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d010(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_regs.a[srcreg];
	BYTE src = get_byte(srca);
{	BYTE dst = m68k_regs.d[dstreg].B.l;
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	m68k_regs.d[dstreg].B.l = newv;
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d018(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_regs.a[srcreg];
	BYTE src = get_byte(srca);
{	m68k_regs.a[srcreg] += areg_byteinc[srcreg];
{	BYTE dst = m68k_regs.d[dstreg].B.l;
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
	m68k_regs.d[dstreg].B.l = newv;
}}}}}}}}
void op_d020(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	m68k_regs.a[srcreg] -= areg_byteinc[srcreg];
{	CPTR srca = m68k_regs.a[srcreg];
	BYTE src = get_byte(srca);
{	BYTE dst = m68k_regs.d[dstreg].B.l;
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
	m68k_regs.d[dstreg].B.l = newv;
}}}}}}}}
void op_d028(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_regs.a[srcreg] + (LONG)(WORD)nextiword();
	BYTE src = get_byte(srca);
{	BYTE dst = m68k_regs.d[dstreg].B.l;
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	m68k_regs.d[dstreg].B.l = newv;
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d030(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = get_disp_ea(m68k_regs.a[srcreg]);
{	BYTE src = get_byte(srca);
{	BYTE dst = m68k_regs.d[dstreg].B.l;
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	m68k_regs.d[dstreg].B.l = newv;
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d038(void) /* ADD */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = (LONG)(WORD)nextiword();
	BYTE src = get_byte(srca);
{	BYTE dst = m68k_regs.d[dstreg].B.l;
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	m68k_regs.d[dstreg].B.l = newv;
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d039(void) /* ADD */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = nextilong();
	BYTE src = get_byte(srca);
{	BYTE dst = m68k_regs.d[dstreg].B.l;
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	m68k_regs.d[dstreg].B.l = newv;
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d03a(void) /* ADD */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_getpc();
	srca += (LONG)(WORD)nextiword();
{	BYTE src = get_byte(srca);
{	BYTE dst = m68k_regs.d[dstreg].B.l;
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	m68k_regs.d[dstreg].B.l = newv;
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d03b(void) /* ADD */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = get_disp_ea(m68k_getpc());
{	BYTE src = get_byte(srca);
{	BYTE dst = m68k_regs.d[dstreg].B.l;
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	m68k_regs.d[dstreg].B.l = newv;
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d03c(void) /* ADD */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	BYTE src = nextiword();
{	BYTE dst = m68k_regs.d[dstreg].B.l;
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	m68k_regs.d[dstreg].B.l = newv;
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d040(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	WORD src = m68k_regs.d[srcreg].W.l;
{	WORD dst = m68k_regs.d[dstreg].W.l;
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	m68k_regs.d[dstreg].W.l = newv;
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d048(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	WORD src = m68k_regs.a[srcreg];
{	WORD dst = m68k_regs.d[dstreg].W.l;
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	m68k_regs.d[dstreg].W.l = newv;
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d050(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_regs.a[srcreg];
	WORD src = get_word(srca);
{	WORD dst = m68k_regs.d[dstreg].W.l;
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	m68k_regs.d[dstreg].W.l = newv;
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d058(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_regs.a[srcreg];
	WORD src = get_word(srca);
{	m68k_regs.a[srcreg] += 2;
{	WORD dst = m68k_regs.d[dstreg].W.l;
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	m68k_regs.d[dstreg].W.l = newv;
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d060(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	m68k_regs.a[srcreg] -= 2;
{	CPTR srca = m68k_regs.a[srcreg];
	WORD src = get_word(srca);
{	WORD dst = m68k_regs.d[dstreg].W.l;
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	m68k_regs.d[dstreg].W.l = newv;
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d068(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_regs.a[srcreg] + (LONG)(WORD)nextiword();
	WORD src = get_word(srca);
{	WORD dst = m68k_regs.d[dstreg].W.l;
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	m68k_regs.d[dstreg].W.l = newv;
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d070(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = get_disp_ea(m68k_regs.a[srcreg]);
{	WORD src = get_word(srca);
{	WORD dst = m68k_regs.d[dstreg].W.l;
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	m68k_regs.d[dstreg].W.l = newv;
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d078(void) /* ADD */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = (LONG)(WORD)nextiword();
	WORD src = get_word(srca);
{	WORD dst = m68k_regs.d[dstreg].W.l;
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	m68k_regs.d[dstreg].W.l = newv;
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d079(void) /* ADD */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = nextilong();
	WORD src = get_word(srca);
{	WORD dst = m68k_regs.d[dstreg].W.l;
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	m68k_regs.d[dstreg].W.l = newv;
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d07a(void) /* ADD */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_getpc();
	srca += (LONG)(WORD)nextiword();
{	WORD src = get_word(srca);
{	WORD dst = m68k_regs.d[dstreg].W.l;
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	m68k_regs.d[dstreg].W.l = newv;
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d07b(void) /* ADD */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = get_disp_ea(m68k_getpc());
{	WORD src = get_word(srca);
{	WORD dst = m68k_regs.d[dstreg].W.l;
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	m68k_regs.d[dstreg].W.l = newv;
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d07c(void) /* ADD */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	WORD src = nextiword();
{	WORD dst = m68k_regs.d[dstreg].W.l;
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	m68k_regs.d[dstreg].W.l = newv;
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d080(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	LONG src = m68k_regs.d[srcreg].D;
{	LONG dst = m68k_regs.d[dstreg].D;
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	m68k_regs.d[dstreg].D = (newv);
	ZFLG = ((LONG)(newv)) == 0;
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d088(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	LONG src = m68k_regs.a[srcreg];
{	LONG dst = m68k_regs.d[dstreg].D;
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	m68k_regs.d[dstreg].D = (newv);
	ZFLG = ((LONG)(newv)) == 0;
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d090(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_regs.a[srcreg];
	LONG src = get_long(srca);
{	LONG dst = m68k_regs.d[dstreg].D;
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	m68k_regs.d[dstreg].D = (newv);
	ZFLG = ((LONG)(newv)) == 0;
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d098(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_regs.a[srcreg];
	LONG src = get_long(srca);
{	m68k_regs.a[srcreg] += 4;
{	LONG dst = m68k_regs.d[dstreg].D;
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	m68k_regs.d[dstreg].D = (newv);
	ZFLG = ((LONG)(newv)) == 0;
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d0a0(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	m68k_regs.a[srcreg] -= 4;
{	CPTR srca = m68k_regs.a[srcreg];
	LONG src = get_long(srca);
{	LONG dst = m68k_regs.d[dstreg].D;
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	m68k_regs.d[dstreg].D = (newv);
	ZFLG = ((LONG)(newv)) == 0;
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d0a8(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_regs.a[srcreg] + (LONG)(WORD)nextiword();
	LONG src = get_long(srca);
{	LONG dst = m68k_regs.d[dstreg].D;
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	m68k_regs.d[dstreg].D = (newv);
	ZFLG = ((LONG)(newv)) == 0;
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d0b0(void) /* ADD */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = get_disp_ea(m68k_regs.a[srcreg]);
{	LONG src = get_long(srca);
{	LONG dst = m68k_regs.d[dstreg].D;
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	m68k_regs.d[dstreg].D = (newv);
	ZFLG = ((LONG)(newv)) == 0;
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d0b8(void) /* ADD */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = (LONG)(WORD)nextiword();
	LONG src = get_long(srca);
{	LONG dst = m68k_regs.d[dstreg].D;
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	m68k_regs.d[dstreg].D = (newv);
	ZFLG = ((LONG)(newv)) == 0;
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d0b9(void) /* ADD */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = nextilong();
	LONG src = get_long(srca);
{	LONG dst = m68k_regs.d[dstreg].D;
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	m68k_regs.d[dstreg].D = (newv);
	ZFLG = ((LONG)(newv)) == 0;
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d0ba(void) /* ADD */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_getpc();
	srca += (LONG)(WORD)nextiword();
{	LONG src = get_long(srca);
{	LONG dst = m68k_regs.d[dstreg].D;
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	m68k_regs.d[dstreg].D = (newv);
	ZFLG = ((LONG)(newv)) == 0;
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d0bb(void) /* ADD */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = get_disp_ea(m68k_getpc());
{	LONG src = get_long(srca);
{	LONG dst = m68k_regs.d[dstreg].D;
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	m68k_regs.d[dstreg].D = (newv);
	ZFLG = ((LONG)(newv)) == 0;
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d0bc(void) /* ADD */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	LONG src = nextilong();
{	LONG dst = m68k_regs.d[dstreg].D;
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	m68k_regs.d[dstreg].D = (newv);
	ZFLG = ((LONG)(newv)) == 0;
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d0c0(void) /* ADDA */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	WORD src = m68k_regs.d[srcreg].W.l;
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}
void op_d0c8(void) /* ADDA */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	WORD src = m68k_regs.a[srcreg];
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}
void op_d0d0(void) /* ADDA */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_regs.a[srcreg];
	WORD src = get_word(srca);
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}
void op_d0d8(void) /* ADDA */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_regs.a[srcreg];
	WORD src = get_word(srca);
{	m68k_regs.a[srcreg] += 2;
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}}
void op_d0e0(void) /* ADDA */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	m68k_regs.a[srcreg] -= 2;
{	CPTR srca = m68k_regs.a[srcreg];
	WORD src = get_word(srca);
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}}
void op_d0e8(void) /* ADDA */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_regs.a[srcreg] + (LONG)(WORD)nextiword();
	WORD src = get_word(srca);
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}
void op_d0f0(void) /* ADDA */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = get_disp_ea(m68k_regs.a[srcreg]);
{	WORD src = get_word(srca);
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}}
void op_d0f8(void) /* ADDA */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = (LONG)(WORD)nextiword();
	WORD src = get_word(srca);
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}
void op_d0f9(void) /* ADDA */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = nextilong();
	WORD src = get_word(srca);
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}
void op_d0fa(void) /* ADDA */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_getpc();
	srca += (LONG)(WORD)nextiword();
{	WORD src = get_word(srca);
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}}
void op_d0fb(void) /* ADDA */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = get_disp_ea(m68k_getpc());
{	WORD src = get_word(srca);
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}}
void op_d0fc(void) /* ADDA */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	WORD src = nextiword();
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}
void op_d100(void) /* ADDX */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	BYTE src = m68k_regs.d[srcreg].B.l;
{	BYTE dst = m68k_regs.d[dstreg].B.l;
{	ULONG newv = dst + src + (m68k_regs.x ? 1 : 0);
	m68k_regs.d[dstreg].B.l = newv;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs && flgo && !flgn) || (!flgs && !flgo && flgn);
	m68k_regs.x = CFLG = (flgs && flgo) || (!flgn && (flgo || flgs));
	if (((BYTE)(newv)) != 0) ZFLG = 0;
	NFLG = ((BYTE)(newv)) < 0;
}}}}}}

void op_d108(void) /* ADDX */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
	m68k_regs.a[srcreg] -= areg_byteinc[srcreg];
{	CPTR srca = m68k_regs.a[srcreg];
	BYTE src = get_byte(srca);
	m68k_regs.a[dstreg] -= areg_byteinc[dstreg];
{	CPTR dsta = m68k_regs.a[dstreg];
	BYTE dst = get_byte(dsta);
	ULONG newv = dst + src + (m68k_regs.x ? 1 : 0);
	put_byte(dsta,newv);
	if (((BYTE)(newv)) != 0) ZFLG = 0;
	NFLG = ((BYTE)(newv)) < 0;
{	int flgn = ((BYTE)(newv)) < 0;
	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	VFLG = (flgs && flgo && !flgn) || (!flgs && !flgo && flgn);
	m68k_regs.x = CFLG = (flgs && flgo) || (!flgn && (flgo || flgs));
}}}}

void op_d110(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
	ULONG dstreg = opcode & 7;
{{	BYTE src = m68k_regs.d[srcreg].B.l;
{	CPTR dsta = m68k_regs.a[dstreg];
	BYTE dst = get_byte(dsta);
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	put_byte(dsta,newv);
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d118(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
	ULONG dstreg = opcode & 7;
	BYTE src = m68k_regs.d[srcreg].B.l;
	CPTR dsta = m68k_regs.a[dstreg];
	BYTE dst = get_byte(dsta);
	m68k_regs.a[dstreg] += areg_byteinc[dstreg];
{	ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	put_byte(dsta,newv);
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgn = ((BYTE)(newv)) < 0;
	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
}}}

void op_d120(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
	ULONG dstreg = opcode & 7;
{{	BYTE src = m68k_regs.d[srcreg].B.l;
{	m68k_regs.a[dstreg] -= areg_byteinc[dstreg];
{	CPTR dsta = m68k_regs.a[dstreg];
	BYTE dst = get_byte(dsta);
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	put_byte(dsta,newv);
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d128(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
	ULONG dstreg = opcode & 7;
{{	BYTE src = m68k_regs.d[srcreg].B.l;
{	CPTR dsta = m68k_regs.a[dstreg] + (LONG)(WORD)nextiword();
	BYTE dst = get_byte(dsta);
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	put_byte(dsta,newv);
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d130(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
	ULONG dstreg = opcode & 7;
{{	BYTE src = m68k_regs.d[srcreg].B.l;
{	CPTR dsta = get_disp_ea(m68k_regs.a[dstreg]);
{	BYTE dst = get_byte(dsta);
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	put_byte(dsta,newv);
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d138(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
{{	BYTE src = m68k_regs.d[srcreg].B.l;
{	CPTR dsta = (LONG)(WORD)nextiword();
	BYTE dst = get_byte(dsta);
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	put_byte(dsta,newv);
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d139(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
{{	BYTE src = m68k_regs.d[srcreg].B.l;
{	CPTR dsta = nextilong();
	BYTE dst = get_byte(dsta);
{{ULONG newv = ((BYTE)(dst)) + ((BYTE)(src));
	put_byte(dsta,newv);
	ZFLG = ((BYTE)(newv)) == 0;
{	int flgs = ((BYTE)(src)) < 0;
	int flgo = ((BYTE)(dst)) < 0;
	int flgn = ((BYTE)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d140(void) /* ADDX */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	WORD src = m68k_regs.d[srcreg].W.l;
{	WORD dst = m68k_regs.d[dstreg].W.l;
{	ULONG newv = dst + src + (m68k_regs.x ? 1 : 0);
	m68k_regs.d[dstreg].W.l = newv;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs && flgo && !flgn) || (!flgs && !flgo && flgn);
	m68k_regs.x = CFLG = (flgs && flgo) || (!flgn && (flgo || flgs));
	if (((WORD)(newv)) != 0) ZFLG = 0;
	NFLG = ((WORD)(newv)) < 0;
}}}}}}
void op_d148(void) /* ADDX */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	m68k_regs.a[srcreg] -= 2;
{	CPTR srca = m68k_regs.a[srcreg];
	WORD src = get_word(srca);
{	m68k_regs.a[dstreg] -= 2;
{	CPTR dsta = m68k_regs.a[dstreg];
	WORD dst = get_word(dsta);
{	ULONG newv = dst + src + (m68k_regs.x ? 1 : 0);
	put_word(dsta,newv);
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs && flgo && !flgn) || (!flgs && !flgo && flgn);
	m68k_regs.x = CFLG = (flgs && flgo) || (!flgn && (flgo || flgs));
	if (((WORD)(newv)) != 0) ZFLG = 0;
	NFLG = ((WORD)(newv)) < 0;
}}}}}}}}
void op_d150(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
	ULONG dstreg = opcode & 7;
{{	WORD src = m68k_regs.d[srcreg].W.l;
{	CPTR dsta = m68k_regs.a[dstreg];
	WORD dst = get_word(dsta);
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	put_word(dsta,newv);
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	ZFLG = ((WORD)(newv)) == 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d158(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
	ULONG dstreg = opcode & 7;
{{	WORD src = m68k_regs.d[srcreg].W.l;
{	CPTR dsta = m68k_regs.a[dstreg];
	WORD dst = get_word(dsta);
{	m68k_regs.a[dstreg] += 2;
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	put_word(dsta,newv);
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	ZFLG = ((WORD)(newv)) == 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d160(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
	ULONG dstreg = opcode & 7;
{{	WORD src = m68k_regs.d[srcreg].W.l;
{	m68k_regs.a[dstreg] -= 2;
{	CPTR dsta = m68k_regs.a[dstreg];
	WORD dst = get_word(dsta);
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	put_word(dsta,newv);
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d168(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
	ULONG dstreg = opcode & 7;
{{	WORD src = m68k_regs.d[srcreg].W.l;
{	CPTR dsta = m68k_regs.a[dstreg] + (LONG)(WORD)nextiword();
	WORD dst = get_word(dsta);
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	put_word(dsta,newv);
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d170(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
	ULONG dstreg = opcode & 7;
{{	WORD src = m68k_regs.d[srcreg].W.l;
{	CPTR dsta = get_disp_ea(m68k_regs.a[dstreg]);
{	WORD dst = get_word(dsta);
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	put_word(dsta,newv);
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d178(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
{{	WORD src = m68k_regs.d[srcreg].W.l;
{	CPTR dsta = (LONG)(WORD)nextiword();
	WORD dst = get_word(dsta);
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	put_word(dsta,newv);
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d179(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
{{	WORD src = m68k_regs.d[srcreg].W.l;
{	CPTR dsta = nextilong();
	WORD dst = get_word(dsta);
{{ULONG newv = ((WORD)(dst)) + ((WORD)(src));
	put_word(dsta,newv);
	ZFLG = ((WORD)(newv)) == 0;
{	int flgs = ((WORD)(src)) < 0;
	int flgo = ((WORD)(dst)) < 0;
	int flgn = ((WORD)(newv)) < 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d180(void) /* ADDX */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	LONG src = m68k_regs.d[srcreg].D;
{	LONG dst = m68k_regs.d[dstreg].D;
{	ULONG newv = dst + src + (m68k_regs.x ? 1 : 0);
	m68k_regs.d[dstreg].D = (newv);
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	VFLG = (flgs && flgo && !flgn) || (!flgs && !flgo && flgn);
	m68k_regs.x = CFLG = (flgs && flgo) || (!flgn && (flgo || flgs));
	if (((LONG)(newv)) != 0) ZFLG = 0;
	NFLG = ((LONG)(newv)) < 0;
}}}}}}
void op_d188(void) /* ADDX */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	m68k_regs.a[srcreg] -= 4;
{	CPTR srca = m68k_regs.a[srcreg];
	LONG src = get_long(srca);
{	m68k_regs.a[dstreg] -= 4;
{	CPTR dsta = m68k_regs.a[dstreg];
	LONG dst = get_long(dsta);
{	ULONG newv = dst + src + (m68k_regs.x ? 1 : 0);
	put_long(dsta,newv);
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	VFLG = (flgs && flgo && !flgn) || (!flgs && !flgo && flgn);
	m68k_regs.x = CFLG = (flgs && flgo) || (!flgn && (flgo || flgs));
	if (((LONG)(newv)) != 0) ZFLG = 0;
	NFLG = ((LONG)(newv)) < 0;
}}}}}}}}
void op_d190(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
	ULONG dstreg = opcode & 7;
{{	LONG src = m68k_regs.d[srcreg].D;
{	CPTR dsta = m68k_regs.a[dstreg];
	LONG dst = get_long(dsta);
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	put_long(dsta,newv);
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	ZFLG = ((LONG)(newv)) == 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d198(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
	ULONG dstreg = opcode & 7;
{{	LONG src = m68k_regs.d[srcreg].D;
{	CPTR dsta = m68k_regs.a[dstreg];
	LONG dst = get_long(dsta);
{	m68k_regs.a[dstreg] += 4;
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	put_long(dsta,newv);
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	ZFLG = ((LONG)(newv)) == 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d1a0(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
	ULONG dstreg = opcode & 7;
{{	LONG src = m68k_regs.d[srcreg].D;
{	m68k_regs.a[dstreg] -= 4;
{	CPTR dsta = m68k_regs.a[dstreg];
	LONG dst = get_long(dsta);
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	put_long(dsta,newv);
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	ZFLG = ((LONG)(newv)) == 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d1a8(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
	ULONG dstreg = opcode & 7;
{{	LONG src = m68k_regs.d[srcreg].D;
{	CPTR dsta = m68k_regs.a[dstreg] + (LONG)(WORD)nextiword();
	LONG dst = get_long(dsta);
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	put_long(dsta,newv);
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	ZFLG = ((LONG)(newv)) == 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d1b0(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
	ULONG dstreg = opcode & 7;
{{	LONG src = m68k_regs.d[srcreg].D;
{	CPTR dsta = get_disp_ea(m68k_regs.a[dstreg]);
{	LONG dst = get_long(dsta);
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	put_long(dsta,newv);
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	ZFLG = ((LONG)(newv)) == 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}}
void op_d1b8(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
{{	LONG src = m68k_regs.d[srcreg].D;
{	CPTR dsta = (LONG)(WORD)nextiword();
	LONG dst = get_long(dsta);
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	put_long(dsta,newv);
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	ZFLG = ((LONG)(newv)) == 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d1b9(void) /* ADD */
{
	ULONG srcreg = ((opcode >> 9) & 7);
{{	LONG src = m68k_regs.d[srcreg].D;
{	CPTR dsta = nextilong();
	LONG dst = get_long(dsta);
{{ULONG newv = ((LONG)(dst)) + ((LONG)(src));
	put_long(dsta,newv);
{	int flgs = ((LONG)(src)) < 0;
	int flgo = ((LONG)(dst)) < 0;
	int flgn = ((LONG)(newv)) < 0;
	ZFLG = ((LONG)(newv)) == 0;
	VFLG = (flgs == flgo) && (flgn != flgo);
	CFLG = m68k_regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
	NFLG = flgn != 0;
}}}}}}}
void op_d1c0(void) /* ADDA */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	LONG src = m68k_regs.d[srcreg].D;
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}
void op_d1c8(void) /* ADDA */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	LONG src = m68k_regs.a[srcreg];
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}
void op_d1d0(void) /* ADDA */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_regs.a[srcreg];
	LONG src = get_long(srca);
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}
void op_d1d8(void) /* ADDA */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_regs.a[srcreg];
	LONG src = get_long(srca);
{	m68k_regs.a[srcreg] += 4;
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}}
void op_d1e0(void) /* ADDA */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	m68k_regs.a[srcreg] -= 4;
{	CPTR srca = m68k_regs.a[srcreg];
	LONG src = get_long(srca);
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}}
void op_d1e8(void) /* ADDA */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_regs.a[srcreg] + (LONG)(WORD)nextiword();
	LONG src = get_long(srca);
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}
void op_d1f0(void) /* ADDA */
{
	ULONG srcreg = (opcode & 7);
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = get_disp_ea(m68k_regs.a[srcreg]);
{	LONG src = get_long(srca);
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}}
void op_d1f8(void) /* ADDA */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = (LONG)(WORD)nextiword();
	LONG src = get_long(srca);
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}
void op_d1f9(void) /* ADDA */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = nextilong();
	LONG src = get_long(srca);
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}
void op_d1fa(void) /* ADDA */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = m68k_getpc();
	srca += (LONG)(WORD)nextiword();
{	LONG src = get_long(srca);
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}}
void op_d1fb(void) /* ADDA */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	CPTR srca = get_disp_ea(m68k_getpc());
{	LONG src = get_long(srca);
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}}
void op_d1fc(void) /* ADDA */
{
	ULONG dstreg = (opcode >> 9) & 7;
{{	LONG src = nextilong();
{	LONG dst = m68k_regs.a[dstreg];
{	ULONG newv = dst + src;
	m68k_regs.a[dstreg] = (newv);
}}}}}
",16366,True,4798.9710769028225,median