ProtocolAdapter 클래스 참조

#include <ProtocolAdapter.h>

ProtocolAdapter에 대한 협력 다이어그램:

클래스
struct	PendingTx
struct	TxResponse

Public 멤버 함수
std::string	onCommand (const std::string &cmdline, const std::weak_ptr< TcpServer::Session > &session)
void	onEd785Response (const ED785Worker::Response &resp)
	ProtocolAdapter (ED785Worker &worker, const AppSettings &settings)

Private 멤버 함수
std::string	sendAndWait (int gcd, int jcd, const std::string &asciiPayload, uint32_t timeoutMs, const std::weak_ptr< TcpServer::Session > &session)

정적 Private 멤버 함수
static std::string	bytesToUtf8String (const std::vector< byte > &buf, size_t len)
static void	ParseAndAppendElectronicMoney (std::vector< std::pair< std::string, std::string > > &kv)
static const char *	rcToText (int rcd)
static std::pair< std::string, std::string >	splitOnce (const std::string &s, char delim)
static std::string	trim (const std::string &s)

Private 속성
std::atomic< bool >	m_deviceReady {true}
std::string	m_lastInitializationError
std::mutex	m_pendingMutex
std::map< uint64_t, std::unique_ptr< PendingTx > >	m_pendingTxs
AppSettings	m_settings
std::mutex	m_stateMutex
std::atomic< uint64_t >	m_txSeq {0}
ED785Worker &	m_worker

생성자 & 소멸자 문서화

ProtocolAdapter()

ProtocolAdapter::ProtocolAdapter	(	ED785Worker &	worker,
		const AppSettings &	settings )

    : m_worker(worker), m_settings(settings)
{
}

다음을 참조함 : m_settings, m_worker.

멤버 함수 문서화

bytesToUtf8String()

std::string ProtocolAdapter::bytesToUtf8String ( const std::vector< byte > & buf, size_t len )

staticprivate

{
    if (len > buf.size())
        len = buf.size();
    std::string euckr(reinterpret_cast<const char *>(buf.data()), reinterpret_cast<const char *>(buf.data()) + len);
    return ConvertEucKrToUtf8(euckr);
}

다음을 참조함 : ConvertEucKrToUtf8().

다음에 의해서 참조됨 : onEd785Response().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

onCommand()

std::string ProtocolAdapter::onCommand	(	const std::string &	cmdline,
		const std::weak_ptr< TcpServer::Session > &	session )

{
    const std::string line = trim(cmdline);
    if (line.empty())
        return "ERR=EMPTY_COMMAND";
 
    Logger::info(L"명령 수신: " + std::wstring(line.begin(), line.end()));
 
    auto [cmd, arg] = splitOnce(line, ' ');
    std::transform(cmd.begin(), cmd.end(), cmd.begin(), [](unsigned char c)
                   { return (char)std::toupper(c); });
 
    if (!m_deviceReady.load(std::memory_order_acquire) && cmd != "PING")
    {
        std::string detail;
        {
            std::lock_guard<std::mutex> stateLock(m_stateMutex);
            detail = m_lastInitializationError;
        }
 
        if (!detail.empty())
            return "ERR=DEVICE_NOT_READY;" + detail;
 
        return "ERR=DEVICE_NOT_READY";
    }
 
    if (cmd == "PING")
        return "PONG";
 
    if (cmd == "INIT")
    {
        // 단말기 초기화 시 기존 대기 중인 모든 트랜잭션 강제 실패 처리
        {
            std::scoped_lock lock(m_pendingMutex);
            if (!m_pendingTxs.empty())
            {
                Logger::warn(std::wstring(L"INIT 명령: 대기 중인 ") + std::to_wstring(m_pendingTxs.size()) + L"개 트랜잭션 강제 취소");
 
                for (auto &pair : m_pendingTxs)
                {
                    TxResponse cancelResp;
                    cancelResp.rcd = 0xFF; // RC_FAILURE
                    cancelResp.data = "CANCELED";
 
                    try
                    {
                        pair.second->promise.set_value(std::move(cancelResp));
                    }
                    catch (const std::exception &)
                    {
                        // promise가 이미 설정된 경우 무시
                    }
                }
 
                m_pendingTxs.clear();
            }
        }
 
        // 단말기 초기화 (0x14, 0x01) - Fire-and-Forget (응답 없음)
        ED785Worker::Request req;
        req.cmd = 0xFB;
        req.gcd = 0x14;
        req.jcd = 0x01;
        req.payload.clear();
 
        if (!m_worker.enqueue(req))
        {
            Logger::error(L"INIT 명령 전송 실패");
            return "ERR=ENQUEUE_FAILED";
        }
 
        Logger::info(L"INIT 명령 전송 완료 (응답 대기 안 함)");
 
        // INIT은 응답이 없으므로 즉시 성공 반환
        // 단말정보가 필요하면 TERMINFO 명령을 별도로 호출
        return "INIT_OK";
    }
 
    if (cmd == "TERMINFO")
        return sendAndWait(0x14, 0x02, "", 10000, session);
 
    if (cmd == "DISPLAY")
        return sendAndWait(0x14, 0x03, arg, 10000, session);
 
    if (cmd == "APPROVE" || cmd == "CANCEL")
    {
        std::string kvs = arg;
        if (cmd == "CANCEL")
        {
            if (kvs.find("S01=") == std::string::npos)
            {
                if (!kvs.empty() && kvs.back() != ';')
                    kvs.push_back(';');
                kvs += "S01=D4;";
            }
            auto tmp = ParseKvOrdered(kvs);
            if (!HasKv(tmp, "S12") || !HasKv(tmp, "S13"))
            {
                Logger::warn(L"취소 요청 거부: 원승인번호/일자 누락");
                return "ERR=MISSING_APPROVAL_INFO";
            }
        }
 
        // S23 자동 주입
        if (kvs.find("S23=") == std::string::npos)
        {
            auto now = std::chrono::system_clock::now();
            std::time_t t = std::chrono::system_clock::to_time_t(now);
            std::tm tm{};
            localtime_s(&tm, &t);
            char ts[16] = {0};
            std::snprintf(ts, sizeof(ts), "%02d%02d%02d%02d%02d%02d",
                          (tm.tm_year + 1900) % 100, tm.tm_mon + 1, tm.tm_mday,
                          tm.tm_hour, tm.tm_min, tm.tm_sec);
            uint64_t seq = m_txSeq.load() + 1;
            char seqbuf[5] = {0};
            std::snprintf(seqbuf, sizeof(seqbuf), "%04llu", (unsigned long long)(seq % 10000));
            std::ostringstream s23;
            s23 << "POS" << ts << seqbuf;
            if (!kvs.empty() && kvs.back() != ';')
                kvs.push_back(';');
            kvs += "S23=";
            kvs += s23.str();
            kvs.push_back(';');
        }
 
        // S23 길이 제한 (20 바이트)
        {
            auto kvList = ParseKvOrdered(kvs);
            bool changed = false;
            for (auto &p : kvList)
            {
                if (_stricmp(p.first.c_str(), "S23") == 0 && p.second.size() > 20)
                {
                    p.second = p.second.substr(0, 20);
                    changed = true;
                }
            }
            if (changed)
            {
                kvs = JoinKvOrdered(kvList);
                if (!kvs.empty() && kvs.back() != ';')
                    kvs.push_back(';');
            }
        }
 
        return sendAndWait(0x14, 0x04, kvs, 60000, session);
    }
 
    if (cmd == "PRINT")
        return sendAndWait(0x14, 0x05, arg, 10000, session);
 
    if (cmd == "READ_SNO")
    {
        std::string opt = trim(arg);
        std::string payload = opt == "R" ? "R" : "";
        return sendAndWait(0x01, 0x06, payload, 10000, session);
    }
 
    return "ERR=UNKNOWN_COMMAND";
}

다음을 참조함 : ED785Worker::Request::cmd, ProtocolAdapter::TxResponse::data, ED785Worker::Request::gcd, HasKv(), ED785Worker::Request::jcd, JoinKvOrdered(), m_deviceReady, m_lastInitializationError, m_pendingMutex, m_pendingTxs, m_stateMutex, m_txSeq, m_worker, ParseKvOrdered(), ED785Worker::Request::payload, ProtocolAdapter::TxResponse::rcd, sendAndWait(), splitOnce(), trim().

다음에 의해서 참조됨 : wWinMain().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

onEd785Response()

void ProtocolAdapter::onEd785Response

(

const ED785Worker::Response &

resp

)

{
    // EUC-KR → UTF-8 변환
    std::string dataStr = bytesToUtf8String(resp.data, resp.dataLen);
 
    if (resp.cmd == ED785Worker::ResponseCmdInternal &&
        resp.gcd == ED785Worker::ResponseGcdInitializationFailure &&
        resp.jcd == ED785Worker::ResponseJcdInitializationFailure)
    {
        std::string reason = dataStr.empty() ? "PORT_INIT_FAILED" : dataStr;
        for (char &ch : reason)
        {
            if (ch == '\r' || ch == '\n' || ch == ';')
                ch = ' ';
        }
 
        std::string code = "PORT_INIT_FAILED";
        if (reason == "PORT_OPEN_FAILED")
            code = "PORT_OPEN_FAILED";
        else if (reason.rfind("DLL_LOAD_FAILED", 0) == 0)
            code = "DLL_LOAD_FAILED";
        else if (reason == "DUMMY_WINDOW_CREATE_FAILED")
            code = "WINDOW_CREATE_FAILED";
 
        const std::string detailPayload = "CODE=" + code + ";MESSAGE=" + reason;
 
        m_deviceReady.store(false, std::memory_order_release);
        {
            std::lock_guard<std::mutex> stateLock(m_stateMutex);
            m_lastInitializationError = detailPayload;
        }
 
        std::wstring wReason = Utf8ToWide(reason);
        if (wReason.empty())
            wReason.assign(reason.begin(), reason.end());
        Logger::error(L"ED785 초기화 실패 이벤트 수신: " + wReason);
 
        std::vector<std::weak_ptr<TcpServer::Session>> targets;
        {
            std::scoped_lock lock(m_pendingMutex);
            targets.reserve(m_pendingTxs.size());
            for (auto &pending : m_pendingTxs)
            {
                TxResponse cancelResp;
                cancelResp.rcd = 0xFF;
                cancelResp.data = "DEVICE_NOT_READY";
                try
                {
                    pending.second->promise.set_value(cancelResp);
                }
                catch (const std::exception &)
                {
                }
                targets.emplace_back(pending.second->session);
            }
            m_pendingTxs.clear();
        }
 
        for (auto &target : targets)
        {
            if (auto session = target.lock())
            {
                std::ostringstream os;
                os << "EVENT=DEVICE_ERROR;" << detailPayload;
                session->sendLine(os.str());
            }
        }
 
        return;
    }
 
    // 모든 ED785 응답 로깅
    {
        std::wstringstream ss;
        ss << L"ED785 응답: cmd=0x" << std::hex << resp.cmd
           << L" gcd=0x" << resp.gcd
           << L" jcd=0x" << resp.jcd
           << L" rcd=" << rcToText(resp.rcd)
           << L" dataLen=" << std::dec << resp.dataLen;
        Logger::debug(ss.str());
    }
 
    // 0xFB 0x14 0x09 : 단말기 상태 정보 (비동기 이벤트)
    if (resp.gcd == 0x14 && resp.jcd == 0x09)
    {
        std::string statusCode;
        if (resp.dataLen >= 2)
        {
            statusCode.assign(reinterpret_cast<const char *>(resp.data.data()), 2);
        }
        else if (!dataStr.empty())
        {
            statusCode = dataStr.substr(0, 2);
        }
 
        std::wstring wStatus(statusCode.begin(), statusCode.end());
        std::wstring desc = L"알수없음";
        if (statusCode == "01")
            desc = L"신용카드 투입";
        else if (statusCode == "02")
            desc = L"서버로 접속 시도";
        else if (statusCode == "03")
            desc = L"FALLBACK 상황 발생";
        else if (statusCode == "04")
            desc = L"승인 불가능한 카드 인입";
 
        const char *rcA = rcToText(resp.rcd);
        std::wstring wRc(rcA, rcA + strlen(rcA));
 
        std::wstringstream ss;
        ss << L"단말기 상태 이벤트 수신 (0x14/0x09) - RC=" << wRc
           << L", STATUS=" << wStatus << L" (" << desc << L")";
        Logger::info(ss.str());
 
        std::vector<std::pair<uint64_t, std::weak_ptr<TcpServer::Session>>> targets;
        {
            std::scoped_lock lock(m_pendingMutex);
            targets.reserve(m_pendingTxs.size());
            for (auto &pending : m_pendingTxs)
            {
                targets.emplace_back(pending.first, pending.second->session);
            }
        }
 
        std::string detail = "UNKNOWN";
        if (statusCode == "01")
            detail = "CARD_INSERTED";
        else if (statusCode == "02")
            detail = "SERVER_CONNECTING";
        else if (statusCode == "03")
            detail = "FALLBACK";
        else if (statusCode == "04")
            detail = "CARD_REJECTED";
 
        for (auto &target : targets)
        {
            if (auto session = target.second.lock())
            {
                std::ostringstream os;
                os << "EVENT=TERMINAL_STATUS;CODE=" << statusCode << ";DETAIL=" << detail << ";TXID=" << target.first;
                session->sendLine(os.str());
            }
        }
 
        // 상태 이벤트는 요청 매칭 대상이 아니므로 여기서 처리 종료 (불필요한 경고 로그 방지)
        return;
    }
 
    // 대기 중인 트랜잭션 중 매칭되는 것 찾기
    std::scoped_lock lock(m_pendingMutex);
 
    uint64_t matchedTx = 0;
    PendingTx *matchedPending = nullptr;
 
    for (auto &pair : m_pendingTxs)
    {
        PendingTx *pending = pair.second.get();
        if (resp.cmd == 0xFB && resp.gcd == pending->expectGcd && resp.jcd == pending->expectJcd)
        {
            matchedTx = pair.first;
            matchedPending = pending;
            break;
        }
    }
 
    if (matchedPending)
    {
        // 매칭된 트랜잭션에 응답 전달
        TxResponse txResp;
        txResp.rcd = resp.rcd;
 
        if (resp.gcd == 0x01 && resp.jcd == 0x06 && resp.hexLen > 0)
            txResp.data = BytesToHexUpper(resp.hex, resp.hexLen);
        else
            txResp.data = dataStr;
 
        {
            std::wstringstream ss;
            ss << L"응답 매칭 성공: TX#" << matchedTx
               << L" gcd=0x" << std::hex << resp.gcd
               << L" jcd=0x" << resp.jcd
               << L" RC=" << rcToText(resp.rcd);
            Logger::info(ss.str());
        }
 
        matchedPending->promise.set_value(std::move(txResp));
    }
    else
    {
        // 매칭되는 대기 트랜잭션이 없음
        std::wstringstream ss;
        ss << L"응답 매칭 실패: 대기 중인 트랜잭션 없음 (현재 " << m_pendingTxs.size() << L"개 대기 중)"
           << L" gcd=0x" << std::hex << resp.gcd
           << L" jcd=0x" << resp.jcd;
        Logger::warn(ss.str());
    }
}

다음을 참조함 : BytesToHexUpper(), bytesToUtf8String(), ED785Worker::Response::cmd, ED785Worker::Response::data, ProtocolAdapter::TxResponse::data, ED785Worker::Response::dataLen, ProtocolAdapter::PendingTx::expectGcd, ProtocolAdapter::PendingTx::expectJcd, ED785Worker::Response::gcd, ED785Worker::Response::hex, ED785Worker::Response::hexLen, ED785Worker::Response::jcd, m_deviceReady, m_lastInitializationError, m_pendingMutex, m_pendingTxs, m_stateMutex, ProtocolAdapter::PendingTx::promise, ED785Worker::Response::rcd, ProtocolAdapter::TxResponse::rcd, rcToText(), ED785Worker::ResponseCmdInternal, ED785Worker::ResponseGcdInitializationFailure, ED785Worker::ResponseJcdInitializationFailure, Utf8ToWide().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

ParseAndAppendElectronicMoney()

void ProtocolAdapter::ParseAndAppendElectronicMoney ( std::vector< std::pair< std::string, std::string > > & kv )

staticprivate

{
    // R32: 전자화폐 결과전문, R33: 전자화폐 구분
    if (!HasKv(kv, "R32"))
        return;
 
    std::string r32 = GetKv(kv, "R32");
    std::string r33 = GetKv(kv, "R33");
 
    if (r32.empty())
        return;
 
    bool isTMoney = (r33 == "TM");
    bool isCashBee = (r33 == "EB" || r33 == "CB");
    bool isRailPlus = (r33 == "RP");
 
    // 자동 판단
    if (!isTMoney && !isCashBee && !isRailPlus)
    {
        if (r32.size() >= 239 && r32.size() < 300)
            isTMoney = true;
        else if (r32.size() >= 334)
            isCashBee = true;
        else if (r32.size() == 4 || r32.size() == 55)
            isRailPlus = true;
    }
 
    if (isTMoney)
    {
        auto tmResult = ElectronicMoneyParser::ParseTMoney(r32);
        if (tmResult.isValid)
        {
            kv.emplace_back("EM_TYPE", "TMONEY");
            auto tmKv = ElectronicMoneyParser::TMoneyToKeyValue(tmResult);
            for (auto &p : tmKv)
                kv.push_back(p);
            Logger::info(L"티머니 전문 파싱 성공");
        }
        else
        {
            if (r32.size() >= 3)
            {
                auto tmError = ElectronicMoneyParser::ParseTMoneyError(r32);
                if (tmError.isValid)
                {
                    kv.emplace_back("EM_TYPE", "TMONEY_ERROR");
                    kv.emplace_back("TM_ERROR_MSG", tmError.errorMessage);
                    Logger::warn(L"티머니 에러: " + std::wstring(tmError.errorMessage.begin(), tmError.errorMessage.end()));
                }
            }
        }
    }
    else if (isCashBee)
    {
        auto cbResult = ElectronicMoneyParser::ParseCashBee(r32);
        if (cbResult.isValid)
        {
            kv.emplace_back("EM_TYPE", "CASHBEE");
            auto cbKv = ElectronicMoneyParser::CashBeeToKeyValue(cbResult);
            for (auto &p : cbKv)
                kv.push_back(p);
            Logger::info(L"캐시비 전문 파싱 성공");
        }
        else
        {
            if (r32.size() >= 69)
            {
                auto cbError = ElectronicMoneyParser::ParseCashBeeError(r32);
                if (cbError.isValid)
                {
                    kv.emplace_back("EM_TYPE", "CASHBEE_ERROR");
                    kv.emplace_back("CB_ERROR_MSG", cbError.errorMessage);
                    Logger::warn(L"캐시비 에러: " + std::wstring(cbError.errorMessage.begin(), cbError.errorMessage.end()));
                }
            }
        }
    }
    else if (isRailPlus)
    {
        auto rpResult = ElectronicMoneyParser::ParseRailPlus(r32);
        if (rpResult.isValid)
        {
            kv.emplace_back("EM_TYPE", "RAILPLUS");
            auto rpKv = ElectronicMoneyParser::RailPlusToKeyValue(rpResult);
            for (auto &p : rpKv)
                kv.push_back(p);
            if (rpResult.isSuccess)
                Logger::info(L"레일플러스 전문 파싱 성공");
            else
                Logger::warn(L"레일플러스 실패");
        }
    }
}

다음을 참조함 : ElectronicMoneyParser::CashBeeToKeyValue(), GetKv(), HasKv(), ElectronicMoneyParser::ParseCashBee(), ElectronicMoneyParser::ParseCashBeeError(), ElectronicMoneyParser::ParseRailPlus(), ElectronicMoneyParser::ParseTMoney(), ElectronicMoneyParser::ParseTMoneyError(), ElectronicMoneyParser::RailPlusToKeyValue(), ElectronicMoneyParser::TMoneyToKeyValue().

다음에 의해서 참조됨 : sendAndWait().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

rcToText()

const char * ProtocolAdapter::rcToText ( int rcd )

staticprivate

{
    switch (rcd)
    {
    case 0x00:
        return "RC_SUCCESS";
    case 0xFF:
        return "RC_FAILURE";
    case 0xFA:
        return "RC_BUSY";
    case 0xF9:
        return "RC_INVALID_COMMAND";
    case 0xF8:
        return "RC_INVALID_DATA";
    default:
        return "RC_UNKNOWN";
    }
}

다음에 의해서 참조됨 : onEd785Response(), sendAndWait().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

sendAndWait()

std::string ProtocolAdapter::sendAndWait ( int gcd, int jcd, const std::string & asciiPayload, uint32_t timeoutMs, const std::weak_ptr< TcpServer::Session > & session )

private

{
    uint64_t tx = ++m_txSeq;
    Logger::info(std::wstring(L"TX#") + std::to_wstring(tx) + L" 요청");
 
    // 트랜잭션 대기 상태 등록
    std::future<TxResponse> future;
    {
        std::scoped_lock lock(m_pendingMutex);
        auto pending = std::make_unique<PendingTx>(gcd, jcd, session);
        future = pending->promise.get_future();
        m_pendingTxs[tx] = std::move(pending);
    }
 
    // ED785 요청 큐잉
    ED785Worker::Request req;
    req.cmd = 0xFB;
    req.gcd = gcd;
    req.jcd = jcd;
    req.payload.assign(asciiPayload.begin(), asciiPayload.end());
 
    if (!m_worker.enqueue(req))
    {
        // 등록한 대기 상태 제거
        {
            std::scoped_lock lock(m_pendingMutex);
            m_pendingTxs.erase(tx);
        }
        Logger::error(L"요청 큐 추가 실패");
        return "ERR=ENQUEUE_FAILED";
    }
 
    // 응답 대기 (future wait_for)
    auto status = future.wait_for(std::chrono::milliseconds(timeoutMs));
 
    // 대기 상태 제거
    {
        std::scoped_lock lock(m_pendingMutex);
        m_pendingTxs.erase(tx);
    }
 
    if (status == std::future_status::timeout)
    {
        Logger::warn(L"응답 타임아웃");
        return "ERR=TIMEOUT";
    }
 
    // 응답 수신 완료
    TxResponse txResp = future.get();
    std::string result;
 
    // 응답 구성
    const bool isApprove = (gcd == 0x14) && (jcd == 0x04);
    if (isApprove)
    {
        auto kv = ParseKvOrdered(txResp.data);
        if (kv.empty() && !txResp.data.empty())
            kv.emplace_back("MSG", txResp.data);
 
        ParseAndAppendElectronicMoney(kv);
 
        std::ostringstream os;
        os << "RC=" << rcToText(txResp.rcd) << ';' << JoinKvOrdered(kv);
        result = os.str();
 
        // 로그 출력 (UTF-8 → UTF-16 변환)
        int wlen = ::MultiByteToWideChar(CP_UTF8, 0, result.c_str(), (int)result.size(), nullptr, 0);
        std::wstring wResult;
        if (wlen > 0)
        {
            wResult.resize(wlen);
            ::MultiByteToWideChar(CP_UTF8, 0, result.c_str(), (int)result.size(), wResult.data(), wlen);
        }
        if (wResult.size() > 300)
            wResult = wResult.substr(0, 300) + L"...";
        Logger::info(L"승인 응답: " + wResult);
    }
    else if (gcd == 0x01 && jcd == 0x06)
    {
        std::ostringstream os;
        os << "RC=" << rcToText(txResp.rcd) << ";SNO=" << txResp.data;
        result = os.str();
    }
    else
    {
        std::ostringstream os;
        os << "RC=" << rcToText(txResp.rcd) << ";DATA=" << txResp.data;
        result = os.str();
    }
 
    Logger::info(std::wstring(L"TX#") + std::to_wstring(tx) + L" 완료");
    return result;
}

다음을 참조함 : ED785Worker::Request::cmd, ProtocolAdapter::TxResponse::data, ED785Worker::Request::gcd, ED785Worker::Request::jcd, JoinKvOrdered(), m_pendingMutex, m_pendingTxs, m_txSeq, m_worker, ParseAndAppendElectronicMoney(), ParseKvOrdered(), ED785Worker::Request::payload, ProtocolAdapter::TxResponse::rcd, rcToText().

다음에 의해서 참조됨 : onCommand().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

splitOnce()

std::pair< std::string, std::string > ProtocolAdapter::splitOnce ( const std::string & s, char delim )

staticprivate

{
    size_t p = s.find(delim);
    if (p == std::string::npos)
        return {s, std::string{}};
    return {s.substr(0, p), s.substr(p + 1)};
}

다음에 의해서 참조됨 : onCommand().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

trim()

std::string ProtocolAdapter::trim ( const std::string & s )

staticprivate

{
    size_t b = s.find_first_not_of("\r\n\t ");
    if (b == std::string::npos)
        return {};
    size_t e = s.find_last_not_of("\r\n\t ");
    return s.substr(b, e - b + 1);
}

다음에 의해서 참조됨 : onCommand().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

멤버 데이터 문서화

m_deviceReady

std::atomic<bool> ProtocolAdapter::m_deviceReady {true}

private

{true};

다음에 의해서 참조됨 : onCommand(), onEd785Response().

m_lastInitializationError

std::string ProtocolAdapter::m_lastInitializationError

private

다음에 의해서 참조됨 : onCommand(), onEd785Response().

m_pendingMutex

std::mutex ProtocolAdapter::m_pendingMutex

private

다음에 의해서 참조됨 : onCommand(), onEd785Response(), sendAndWait().

m_pendingTxs

std::map<uint64_t, std::unique_ptr<PendingTx> > ProtocolAdapter::m_pendingTxs

private

다음에 의해서 참조됨 : onCommand(), onEd785Response(), sendAndWait().

m_settings

AppSettings ProtocolAdapter::m_settings

private

다음에 의해서 참조됨 : ProtocolAdapter().

m_stateMutex

std::mutex ProtocolAdapter::m_stateMutex

private

다음에 의해서 참조됨 : onCommand(), onEd785Response().

m_txSeq

std::atomic<uint64_t> ProtocolAdapter::m_txSeq {0}

private

{0};

다음에 의해서 참조됨 : onCommand(), sendAndWait().

m_worker

ED785Worker& ProtocolAdapter::m_worker

private

다음에 의해서 참조됨 : onCommand(), ProtocolAdapter(), sendAndWait().

---

이 클래스에 대한 문서화 페이지는 다음의 파일들로부터 생성되었습니다.:

• ProtocolAdapter.h
• ProtocolAdapter.cpp