#pragma once
#include <atomic>
typedef std::atomic<unsigned long> counter;
struct MaintainCount
{
    counter & c;
    MaintainCount(counter & c) : c(c) { c++; }
    ~MaintainCount() { auto prev = c--; assert(prev); }
};
    MaintainCount(counter & c, std::function<void(unsigned long)> warn) : c(c)
    {
        warn(++c);
    }
#include <functional>

            auto mc1 = std::make_shared<MaintainCount>(nrStepsWaiting);

            auto mc1 = std::make_shared<MaintainCount<counter>>(nrStepsWaiting);

            MaintainCount mc2(nrStepsCopyingTo);

            MaintainCount<counter> mc2(nrStepsCopyingTo);

            MaintainCount mc(nrStepsBuilding);

            MaintainCount<counter> mc(nrStepsBuilding);

            MaintainCount mc(nrStepsCopyingFrom);

            MaintainCount<counter> mc(nrStepsCopyingFrom);

MaintainCount State::startDbUpdate()

nix::MaintainCount<counter> State::startDbUpdate()

    return MaintainCount(nrActiveDbUpdates, [](unsigned long c) {
        if (c > 6) {
            printMsg(lvlError, format("warning: %d concurrent database updates; PostgreSQL may be stalled") % c);
        }
    });

    if (nrActiveDbUpdates > 6)
        printError("warning: %d concurrent database updates; PostgreSQL may be stalled", nrActiveDbUpdates.load());
    return MaintainCount<counter>(nrActiveDbUpdates);

            MaintainCount mc(nrNotificationsInProgress);

            MaintainCount<counter> mc(nrNotificationsInProgress);

#include "counter.hh"

typedef std::atomic<unsigned long> counter;

    MaintainCount startDbUpdate();

    nix::MaintainCount<counter> startDbUpdate();