Keyple Card Calypso C++ Library - 3.2.2
Component of the Keyple C++ middleware
DtoAdapters.cpp
Go to the documentation of this file.
1/******************************************************************************
2 * Copyright (c) 2025 Calypso Networks Association https://calypsonet.org/ *
3 * *
4 * See the NOTICE file(s) distributed with this work for additional *
5 * information regarding copyright ownership. *
6 * *
7 * This program and the accompanying materials are made available under the *
8 * terms of the Eclipse Public License 2.0 which is available at *
9 * http://www.eclipse.org/legal/epl-2.0 *
10 * *
11 * SPDX-License-Identifier: EPL-2.0 *
12 ******************************************************************************/
13
14#include "keyple/card/calypso/DtoAdapters.hpp"
15
16#include <memory>
17#include <string>
18#include <utility>
19#include <vector>
20
21#include "keyple/core/util/ByteArrayUtil.hpp"
22#include "keyple/core/util/HexUtil.hpp"
23#include "keyple/core/util/cpp/KeypleStd.hpp"
24#include "keyple/core/util/cpp/System.hpp"
25
26namespace keyple {
27namespace card {
28namespace calypso {
29
30using keyple::core::util::ByteArrayUtil;
31using keyple::core::util::HexUtil;
32using keyple::core::util::cpp::System;
33
34const int DtoAdapters::ApduRequestAdapter::DEFAULT_SUCCESSFUL_CODE = 0x9000;
35const int DtoAdapters::CardSelectionRequestAdapter::SW_DEFAULT_SUCCESSFUL
36 = 0x9000;
37
38DtoAdapters::ApduRequestAdapter::ApduRequestAdapter(
39 const std::vector<std::uint8_t>& apdu)
40: mApdu(apdu)
41, mSuccessfulStatusWords({DEFAULT_SUCCESSFUL_CODE})
42{
43}
44
45DtoAdapters::ApduRequestAdapter&
46DtoAdapters::ApduRequestAdapter::addSuccessfulStatusWord(
47 int successfulStatusWord)
48{
49 mSuccessfulStatusWords.push_back(successfulStatusWord);
50
51 return *this;
52}
53
54const std::vector<int>&
55DtoAdapters::ApduRequestAdapter::getSuccessfulStatusWords() const
56{
57 return mSuccessfulStatusWords;
58}
59
60DtoAdapters::ApduRequestAdapter&
61DtoAdapters::ApduRequestAdapter::setInfo(const std::string& info)
62{
63 mInfo = info;
64
65 return *this;
66}
67
68const std::string&
69DtoAdapters::ApduRequestAdapter::getInfo() const
70{
71 return mInfo;
72}
73
74const std::vector<std::uint8_t>&
75DtoAdapters::ApduRequestAdapter::getApdu() const
76{
77 return mApdu;
78}
79
80void
81DtoAdapters::ApduRequestAdapter::setApdu(const std::vector<std::uint8_t>& apdu)
82{
83 mApdu = apdu;
84}
85
86std::ostream&
87operator<<(std::ostream& os, const DtoAdapters::ApduRequestAdapter& ara)
88{
89 os << "APDU_REQUEST_ADAPTER: {"
90 << "APDU = " << ara.getApdu() << ", "
91 << "SUCCESSFUL_STATUS_WORDS = " << ara.getSuccessfulStatusWords() << ", "
92 << "INFO = " << ara.getInfo() << "}";
93
94 return os;
95}
96
97std::ostream&
98operator<<(
99 std::ostream& os,
100 const std::shared_ptr<DtoAdapters::ApduRequestAdapter>& ara)
101{
102 if (ara == nullptr) {
103 os << "APDU_REQUEST_ADAPTER: {null}";
104 } else {
105 os << *ara.get();
106 }
107
108 return os;
109}
110
111DtoAdapters::CardRequestAdapter::CardRequestAdapter(
112 const std::vector<std::shared_ptr<ApduRequestSpi>>& apduRequests,
113 bool stopOnUnsuccessfulStatusWord)
114: mApduRequests(apduRequests)
115, mStopOnUnsuccessfulStatusWord(stopOnUnsuccessfulStatusWord)
116{
117}
118
119const std::vector<std::shared_ptr<ApduRequestSpi>>&
120DtoAdapters::CardRequestAdapter::getApduRequests() const
121{
122 return mApduRequests;
123}
124
125bool
126DtoAdapters::CardRequestAdapter::stopOnUnsuccessfulStatusWord() const
127{
128 return mStopOnUnsuccessfulStatusWord;
129}
130
131std::ostream&
132operator<<(std::ostream& os, const DtoAdapters::CardRequestAdapter& cra)
133{
134 os << "CARD_REQUEST_ADAPTER: {"
135 << "APDU_REQUESTS: {";
136
137 for (const auto& apduRequest : cra.getApduRequests()) {
138 os << apduRequest << ", ";
139 }
140
141 os << "}, STOP_ON_UNSUCCESSFUL_STATUS_WORD: "
142 << cra.stopOnUnsuccessfulStatusWord() << "}";
143
144 return os;
145}
146
147std::ostream&
148operator<<(
149 std::ostream& os,
150 const std::shared_ptr<DtoAdapters::CardRequestAdapter>& cra)
151{
152 if (cra == nullptr) {
153 os << "CARD_REQUEST_ADAPTER: {null}";
154 } else {
155 os << *cra.get();
156 }
157
158 return os;
159}
160
161DtoAdapters::CardSelectionRequestAdapter::CardSelectionRequestAdapter(
162 std::unique_ptr<CardRequestSpi> cardRequest)
163: mCardRequest(std::move(cardRequest))
164, mSuccessfulSelectionStatusWords({SW_DEFAULT_SUCCESSFUL})
165{
166}
167
168void
169DtoAdapters::CardSelectionRequestAdapter::addSuccessfulSelectionStatusWord(
170 int successfulStatusWord)
171{
172 mSuccessfulSelectionStatusWords.push_back(successfulStatusWord);
173}
174
175const std::vector<int>&
176DtoAdapters::CardSelectionRequestAdapter::getSuccessfulSelectionStatusWords()
177 const
178{
179 return mSuccessfulSelectionStatusWords;
180}
181
182const std::shared_ptr<CardRequestSpi>
183DtoAdapters::CardSelectionRequestAdapter::getCardRequest() const
184{
185 return mCardRequest;
186}
187
188std::ostream&
189operator<<(
190 std::ostream& os, const DtoAdapters::CardSelectionRequestAdapter& csra)
191{
192 os << "CARD_SELECTION_REQUEST_ADAPTER: {"
193 << "CARD_REQUEST: " << csra.getCardRequest() << ", "
194 << "SUCCESSFUL_SELECTION_STATUS_WORDS: "
195 << csra.getSuccessfulSelectionStatusWords() << "}";
196
197 return os;
198}
199
200std::ostream&
201operator<<(
202 std::ostream& os,
203 const std::shared_ptr<DtoAdapters::CardSelectionRequestAdapter>& csra)
204{
205 if (csra == nullptr) {
206 os << "CARD_SELECTION_REQUEST_ADAPTER: {null}";
207 } else {
208 os << *csra.get();
209 }
210
211 return os;
212}
213
214DtoAdapters::SearchCommandDataAdapter::SearchCommandDataAdapter()
215: SearchCommandData()
216, mSfi(1)
217, mRecordNumber(1)
218, mOffset(0)
219, mEnableRepeatedOffset(false)
220{
221}
222
223SearchCommandData&
224DtoAdapters::SearchCommandDataAdapter::setSfi(std::uint8_t sfi)
225{
226 mSfi = sfi;
227
228 return *this;
229}
230
231SearchCommandData&
232DtoAdapters::SearchCommandDataAdapter::startAtRecord(int recordNumber)
233{
234 mRecordNumber = recordNumber;
235
236 return *this;
237}
238
239SearchCommandData&
240DtoAdapters::SearchCommandDataAdapter::setOffset(int offset)
241{
242 mOffset = offset;
243
244 return *this;
245}
246
247SearchCommandData&
248DtoAdapters::SearchCommandDataAdapter::enableRepeatedOffset()
249{
250 mEnableRepeatedOffset = true;
251
252 return *this;
253}
254
255SearchCommandData&
256DtoAdapters::SearchCommandDataAdapter::setSearchData(
257 const std::vector<std::uint8_t>& data)
258{
259 mSearchData = data;
260
261 return *this;
262}
263
264SearchCommandData&
265DtoAdapters::SearchCommandDataAdapter::setMask(
266 const std::vector<std::uint8_t>& mask)
267{
268 mMask = mask;
269
270 return *this;
271}
272
273SearchCommandData&
274DtoAdapters::SearchCommandDataAdapter::fetchFirstMatchingResult()
275{
276 mFetchFirstMatchingResult = true;
277
278 return *this;
279}
280
281std::vector<int>&
282DtoAdapters::SearchCommandDataAdapter::getMatchingRecordNumbers()
283{
284 return mMatchingRecordNumbers;
285}
286
287std::uint8_t
288DtoAdapters::SearchCommandDataAdapter::getSfi() const
289{
290 return mSfi;
291}
292
293int
294DtoAdapters::SearchCommandDataAdapter::getRecordNumber() const
295{
296 return mRecordNumber;
297}
298
299int
300DtoAdapters::SearchCommandDataAdapter::getOffset() const
301{
302 return mOffset;
303}
304
305bool
306DtoAdapters::SearchCommandDataAdapter::isEnableRepeatedOffset() const
307{
308 return mEnableRepeatedOffset;
309}
310
311const std::vector<std::uint8_t>&
312DtoAdapters::SearchCommandDataAdapter::getSearchData() const
313{
314 return mSearchData;
315}
316
317const std::vector<std::uint8_t>&
318DtoAdapters::SearchCommandDataAdapter::getMask() const
319{
320 return mMask;
321}
322
323bool
324DtoAdapters::SearchCommandDataAdapter::isFetchFirstMatchingResult() const
325{
326 return mFetchFirstMatchingResult;
327}
328
329const std::vector<std::uint8_t>&
330DtoAdapters::SvCommandSecurityDataApiAdapter::getSvGetRequest() const
331{
332 return mSvGetRequest;
333}
334
335const std::vector<std::uint8_t>&
336DtoAdapters::SvCommandSecurityDataApiAdapter::getSvGetResponse() const
337{
338 return mSvGetResponse;
339}
340
341const std::vector<std::uint8_t>&
342DtoAdapters::SvCommandSecurityDataApiAdapter::getSvCommandPartialRequest() const
343{
344 return mSvCommandPartialRequest;
345}
346
347DtoAdapters::SvCommandSecurityDataApiAdapter&
348DtoAdapters::SvCommandSecurityDataApiAdapter::setSerialNumber(
349 const std::vector<std::uint8_t>& serialNumber)
350{
351 mSerialNumber = serialNumber;
352
353 return *this;
354}
355
356DtoAdapters::SvCommandSecurityDataApiAdapter&
357DtoAdapters::SvCommandSecurityDataApiAdapter::setTransactionNumber(
358 const std::vector<std::uint8_t>& transactionNumber)
359{
360 mTransactionNumber = transactionNumber;
361
362 return *this;
363}
364
365DtoAdapters::SvCommandSecurityDataApiAdapter&
366DtoAdapters::SvCommandSecurityDataApiAdapter::setTerminalChallenge(
367 const std::vector<std::uint8_t>& terminalChallenge)
368{
369 mTerminalChallenge = terminalChallenge;
370
371 return *this;
372}
373
374DtoAdapters::SvCommandSecurityDataApiAdapter&
375DtoAdapters::SvCommandSecurityDataApiAdapter::setTerminalSvMac(
376 const std::vector<std::uint8_t>& terminalSvMac)
377{
378 mTerminalSvMac = terminalSvMac;
379
380 return *this;
381}
382
383SvCommandSecurityDataApi&
384DtoAdapters::SvCommandSecurityDataApiAdapter::setSvGetRequest(
385 const std::vector<std::uint8_t>& svGetRequest)
386{
387 mSvGetRequest = svGetRequest;
388
389 return *this;
390}
391SvCommandSecurityDataApi&
392DtoAdapters::SvCommandSecurityDataApiAdapter::setSvGetResponse(
393 const std::vector<std::uint8_t>& svGetResponse)
394{
395 mSvGetResponse = svGetResponse;
396
397 return *this;
398}
399SvCommandSecurityDataApi&
400DtoAdapters::SvCommandSecurityDataApiAdapter::setSvCommandPartialRequest(
401 const std::vector<std::uint8_t>& svCommandPartialRequest)
402{
403 mSvCommandPartialRequest = svCommandPartialRequest;
404
405 return *this;
406}
407
408const std::vector<std::uint8_t>&
409DtoAdapters::SvCommandSecurityDataApiAdapter::getSerialNumber() const
410{
411 return mSerialNumber;
412}
413
414const std::vector<std::uint8_t>&
415DtoAdapters::SvCommandSecurityDataApiAdapter::getTransactionNumber() const
416{
417 return mTransactionNumber;
418}
419
420const std::vector<std::uint8_t>&
421DtoAdapters::SvCommandSecurityDataApiAdapter::getTerminalChallenge() const
422{
423 return mTerminalChallenge;
424}
425
426const std::vector<std::uint8_t>&
427DtoAdapters::SvCommandSecurityDataApiAdapter::getTerminalSvMac() const
428{
429 return mTerminalSvMac;
430}
431
432DtoAdapters::SvDebitLogRecordAdapter::SvDebitLogRecordAdapter(
433 const std::vector<std::uint8_t>& cardResponse, int offset)
434: mOffset(offset)
435, mCardResponse(cardResponse)
436{
437}
438
439const std::vector<std::uint8_t>&
440DtoAdapters::SvDebitLogRecordAdapter::getRawData() const
441{
442 return mCardResponse;
443}
444
445int
446DtoAdapters::SvDebitLogRecordAdapter::getAmount() const
447{
448 return ByteArrayUtil::extractInt(mCardResponse, mOffset, 2, true);
449}
450
451int
452DtoAdapters::SvDebitLogRecordAdapter::getBalance() const
453{
454 return ByteArrayUtil::extractInt(mCardResponse, mOffset + 14, 3, true);
455}
456
457std::vector<std::uint8_t>
458DtoAdapters::SvDebitLogRecordAdapter::getDebitTime() const
459{
460 std::vector<std::uint8_t> time(2);
461
462 time[0] = mCardResponse[mOffset + 4];
463 time[1] = mCardResponse[mOffset + 5];
464
465 return time;
466}
467
468std::vector<std::uint8_t>
469DtoAdapters::SvDebitLogRecordAdapter::getDebitDate() const
470{
471 std::vector<std::uint8_t> date(2);
472
473 date[0] = mCardResponse[mOffset + 2];
474 date[1] = mCardResponse[mOffset + 3];
475
476 return date;
477}
478
479std::uint8_t
480DtoAdapters::SvDebitLogRecordAdapter::getKvc() const
481{
482 return mCardResponse[mOffset + 6];
483}
484
485std::vector<std::uint8_t>
486DtoAdapters::SvDebitLogRecordAdapter::getSamId() const
487{
488 std::vector<std::uint8_t> samId(4);
489
490 System::arraycopy(mCardResponse, mOffset + 7, samId, 0, 4);
491
492 return samId;
493}
494
495int
496DtoAdapters::SvDebitLogRecordAdapter::getSvTNum() const
497{
498 std::vector<std::uint8_t> tnNum(2);
499
500 tnNum[0] = mCardResponse[mOffset + 17];
501 tnNum[1] = mCardResponse[mOffset + 18];
502
503 return ByteArrayUtil::extractInt(tnNum, 0, 2, false);
504}
505
506int
507DtoAdapters::SvDebitLogRecordAdapter::getSamTNum() const
508{
509 std::vector<std::uint8_t> samTNum(3);
510
511 System::arraycopy(mCardResponse, mOffset + 11, samTNum, 0, 3);
512
513 return ByteArrayUtil::extractInt(samTNum, 0, 3, false);
514}
515
516std::ostream&
517operator<<(std::ostream& os, const DtoAdapters::SvDebitLogRecordAdapter& sdlra)
518{
519 os << "SV_DEBIT_LOG_RECORD_ADAPTER: {"
520 << "AMOUNT: " << sdlra.getAmount() << ", "
521 << "BALANCE: " << sdlra.getBalance() << ", "
522 << "DEBIT_DATE: " << HexUtil::toHex(sdlra.getDebitDate()) << ", "
523 << "DEBIT_TIME: " << HexUtil::toHex(sdlra.getDebitTime()) << ", "
524 << "KVC: " << HexUtil::toHex(sdlra.getKvc()) << ", "
525 << "SAM_ID: " << HexUtil::toHex(sdlra.getSamId()) << ", "
526 << "SV_TRANSACTION_NUMBER: " << sdlra.getSvTNum() << ", "
527 << "SAM_TRANSACTION_NUMBER: " << sdlra.getSamTNum() << "}";
528
529 return os;
530}
531
532std::ostream&
533operator<<(
534 std::ostream& os,
535 const std::shared_ptr<DtoAdapters::SvDebitLogRecordAdapter>& sdlra)
536{
537 if (sdlra == nullptr) {
538 os << "SV_DEBIT_LOG_RECORD_ADAPTER: {null}";
539 } else {
540 os << *sdlra.get();
541 }
542
543 return os;
544}
545
546DtoAdapters::SvLoadLogRecordAdapter::SvLoadLogRecordAdapter(
547 const std::vector<std::uint8_t>& cardResponse, int offset)
548: mOffset(offset)
549, mCardResponse(cardResponse)
550{
551}
552
553const std::vector<std::uint8_t>&
554DtoAdapters::SvLoadLogRecordAdapter::getRawData() const
555{
556 return mCardResponse;
557}
558
559int
560DtoAdapters::SvLoadLogRecordAdapter::getAmount() const
561{
562 return ByteArrayUtil::extractInt(mCardResponse, mOffset + 8, 3, true);
563}
564
565int
566DtoAdapters::SvLoadLogRecordAdapter::getBalance() const
567{
568 return ByteArrayUtil::extractInt(mCardResponse, mOffset + 5, 3, true);
569}
570
571std::vector<std::uint8_t>
572DtoAdapters::SvLoadLogRecordAdapter::getLoadTime() const
573{
574 std::vector<std::uint8_t> time(2);
575
576 time[0] = mCardResponse[mOffset + 11];
577 time[1] = mCardResponse[mOffset + 12];
578
579 return time;
580}
581
582std::vector<std::uint8_t>
583DtoAdapters::SvLoadLogRecordAdapter::getLoadDate() const
584{
585 std::vector<std::uint8_t> date(2);
586
587 date[0] = mCardResponse[mOffset];
588 date[1] = mCardResponse[mOffset + 1];
589
590 return date;
591}
592
593std::vector<std::uint8_t>
594DtoAdapters::SvLoadLogRecordAdapter::getFreeData() const
595{
596 std::vector<std::uint8_t> free(2);
597
598 free[0] = mCardResponse[mOffset + 2];
599 free[1] = mCardResponse[mOffset + 4];
600
601 return free;
602}
603
604std::uint8_t
605DtoAdapters::SvLoadLogRecordAdapter::getKvc() const
606{
607 return mCardResponse[mOffset + 3];
608}
609
610std::vector<std::uint8_t>
611DtoAdapters::SvLoadLogRecordAdapter::getSamId() const
612{
613 std::vector<std::uint8_t> samId(4);
614
615 System::arraycopy(mCardResponse, mOffset + 13, samId, 0, 4);
616
617 return samId;
618}
619
620int
621DtoAdapters::SvLoadLogRecordAdapter::getSvTNum() const
622{
623 std::vector<std::uint8_t> tnNum(2);
624
625 tnNum[0] = mCardResponse[mOffset + 20];
626 tnNum[1] = mCardResponse[mOffset + 21];
627
628 return ByteArrayUtil::extractInt(tnNum, 0, 2, false);
629}
630
631int
632DtoAdapters::SvLoadLogRecordAdapter::getSamTNum() const
633{
634 std::vector<std::uint8_t> samTNum(3);
635
636 System::arraycopy(mCardResponse, mOffset + 17, samTNum, 0, 3);
637
638 return ByteArrayUtil::extractInt(samTNum, 0, 3, false);
639}
640
641std::ostream&
642operator<<(std::ostream& os, const DtoAdapters::SvLoadLogRecordAdapter& sllra)
643{
644 os << "SV_LOAD_LOG_RECORD_ADAPTER: {"
645 << "AMOUNT: " << sllra.getAmount() << ", "
646 << "BALANCE: " << sllra.getBalance() << ", "
647 << "LOAD_DATE: " << HexUtil::toHex(sllra.getLoadDate()) << ", "
648 << "LOAD_TIME: " << HexUtil::toHex(sllra.getLoadTime()) << ", "
649 << "FREE_BYTES: " << HexUtil::toHex(sllra.getFreeData()) << ", "
650 << "KVC: " << HexUtil::toHex(sllra.getKvc()) << ", "
651 << "SAM_ID: " << HexUtil::toHex(sllra.getSamId()) << ", "
652 << "SV_TRANSACTION_NUMBER: " << sllra.getSvTNum() << ", "
653 << "SAM_TRANSACTION_NUMBER: " << sllra.getSamTNum() << "}";
654
655 return os;
656}
657
658std::ostream&
659operator<<(
660 std::ostream& os,
661 const std::shared_ptr<DtoAdapters::SvLoadLogRecordAdapter>& sllra)
662{
663 if (sllra == nullptr) {
664 os << "SV_LOAD_LOG_RECORD_ADAPTER: {null}";
665 } else {
666 os << *sllra.get();
667 }
668
669 return os;
670}
671
672DtoAdapters::CommandContextDto::CommandContextDto(
673 bool isSecureSessionOpen, bool isEncryptionActive)
674: mIsSecureSessionOpen(isSecureSessionOpen)
675, mIsEncryptionActive(isEncryptionActive)
676{
677}
678
679bool
680DtoAdapters::CommandContextDto::isSecureSessionOpen() const
681{
682 return mIsSecureSessionOpen;
683}
684
685bool
686DtoAdapters::CommandContextDto::isEncryptionActive() const
687{
688 return mIsEncryptionActive;
689}
690
691DtoAdapters::TransactionContextDto::TransactionContextDto(
692 std::shared_ptr<CalypsoCardAdapter> card,
693 std::shared_ptr<SymmetricCryptoCardTransactionManagerSpi>
694 symmetricCryptoCardTransactionManagerSpi)
695: mCard(card)
696, mSymmetricCryptoCardTransactionManagerSpi(
697 symmetricCryptoCardTransactionManagerSpi)
698, mAsymmetricCryptoCardTransactionManagerSpi(nullptr)
699, mIsSecureSessionOpen(false)
700{
701}
702
703DtoAdapters::TransactionContextDto::TransactionContextDto(
704 std::shared_ptr<CalypsoCardAdapter> card,
705 std::shared_ptr<AsymmetricCryptoCardTransactionManagerSpi>
706 asymmetricCryptoCardTransactionManagerSpi)
707: mCard(card)
708, mSymmetricCryptoCardTransactionManagerSpi(nullptr)
709, mAsymmetricCryptoCardTransactionManagerSpi(
710 asymmetricCryptoCardTransactionManagerSpi)
711, mIsSecureSessionOpen(false)
712{
713}
714
715DtoAdapters::TransactionContextDto::TransactionContextDto(
716 std::shared_ptr<CalypsoCardAdapter> card)
717: mCard(card)
718, mSymmetricCryptoCardTransactionManagerSpi(nullptr)
719, mAsymmetricCryptoCardTransactionManagerSpi(nullptr)
720, mIsSecureSessionOpen(false)
721{
722}
723
724DtoAdapters::TransactionContextDto::TransactionContextDto()
725: mCard(nullptr)
726, mSymmetricCryptoCardTransactionManagerSpi(nullptr)
727, mAsymmetricCryptoCardTransactionManagerSpi(nullptr)
728, mIsSecureSessionOpen(false)
729{
730}
731
732std::shared_ptr<CalypsoCardAdapter>
733DtoAdapters::TransactionContextDto::getCard() const
734{
735 return mCard;
736}
737
738std::shared_ptr<SymmetricCryptoCardTransactionManagerSpi>
739DtoAdapters::TransactionContextDto ::
740 getSymmetricCryptoCardTransactionManagerSpi() const
741{
742 return mSymmetricCryptoCardTransactionManagerSpi;
743}
744
745std::shared_ptr<AsymmetricCryptoCardTransactionManagerSpi>
746DtoAdapters::TransactionContextDto ::
747 getAsymmetricCryptoCardTransactionManagerSpi() const
748{
749 return mAsymmetricCryptoCardTransactionManagerSpi;
750}
751
752bool
753DtoAdapters::TransactionContextDto::isSecureSessionOpen() const
754{
755 return mIsSecureSessionOpen;
756}
757
758bool
759DtoAdapters::TransactionContextDto::isPkiMode() const
760{
761 return mAsymmetricCryptoCardTransactionManagerSpi != nullptr;
762}
763
764void
765DtoAdapters::TransactionContextDto::setCard(
766 std::shared_ptr<CalypsoCardAdapter> card)
767{
768 mCard = card;
769}
770
771void
772DtoAdapters::TransactionContextDto::setSecureSessionOpen(
773 bool isSecureSessionOpen)
774{
775 mIsSecureSessionOpen = isSecureSessionOpen;
776}
777
778} /* namespace calypso */
779} /* namespace card */
780} /* namespace keyple */
keyple::card::calypso::operator<<
std::ostream & operator<<(std::ostream &os, const std::shared_ptr< DtoAdapters::SvLoadLogRecordAdapter > &sllra)
Definition: DtoAdapters.cpp:659
Generated by doxygen 1.9.2