97 lines
2.7 KiB
C++
97 lines
2.7 KiB
C++
// Copyright (c) 2012-2014, The CryptoNote developers, The Bytecoin developers
|
|
//
|
|
// This file is part of Bytecoin.
|
|
//
|
|
// Bytecoin is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Bytecoin 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 Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with Bytecoin. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#pragma once
|
|
|
|
#include <atomic>
|
|
|
|
#include "include_base_utils.h"
|
|
|
|
namespace tools {
|
|
|
|
class InitState {
|
|
public:
|
|
InitState() : m_state(STATE_NOT_INITIALIZED) {
|
|
}
|
|
|
|
bool initialized() const volatile {
|
|
return STATE_INITIALIZED == m_state.load(std::memory_order_acquire);
|
|
}
|
|
|
|
bool beginInit() volatile {
|
|
State state = STATE_NOT_INITIALIZED;
|
|
if (!m_state.compare_exchange_strong(state, STATE_INITIALIZING, std::memory_order_seq_cst)) {
|
|
LOG_ERROR("object has been already initialized");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool endInit() volatile {
|
|
State expectedState = STATE_INITIALIZING;
|
|
if (!m_state.compare_exchange_strong(expectedState, STATE_INITIALIZED, std::memory_order_seq_cst)) {
|
|
LOG_ERROR("Unexpected state: " << expectedState);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool beginShutdown() volatile {
|
|
while (true) {
|
|
State state = m_state.load(std::memory_order_relaxed);
|
|
if (STATE_NOT_INITIALIZED == state) {
|
|
return true;
|
|
} else if (STATE_INITIALIZING == state) {
|
|
LOG_ERROR("Object is being initialized");
|
|
return false;
|
|
} else if (STATE_INITIALIZED == state) {
|
|
if (m_state.compare_exchange_strong(state, STATE_SHUTTING_DOWN, std::memory_order_seq_cst)) {
|
|
return true;
|
|
}
|
|
} else if (STATE_SHUTTING_DOWN == state) {
|
|
LOG_ERROR("Object is being shutting down");
|
|
return false;
|
|
} else {
|
|
LOG_ERROR("Unknown state " << state);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool endShutdown() volatile {
|
|
State expectedState = STATE_SHUTTING_DOWN;
|
|
if (!m_state.compare_exchange_strong(expectedState, STATE_NOT_INITIALIZED, std::memory_order_seq_cst)) {
|
|
LOG_ERROR("Unexpected state: " << expectedState);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
enum State {
|
|
STATE_NOT_INITIALIZED,
|
|
STATE_INITIALIZING,
|
|
STATE_INITIALIZED,
|
|
STATE_SHUTTING_DOWN
|
|
};
|
|
|
|
private:
|
|
std::atomic<State> m_state;
|
|
};
|
|
|
|
}
|