open62541pp 0.16.0
C++ wrapper of open62541
Loading...
Searching...
No Matches
attribute_highlevel.hpp
Go to the documentation of this file.
1/* ---------------------------------------------------------------------------------------------- */
2/* Generated - do not modify! */
3/* ---------------------------------------------------------------------------------------------- */
4
5#pragma once
6
8
9namespace opcua::services {
10
11/**
12 * Read the AttributeId::NodeId attribute of a node.
13 * @param connection Instance of type Client (or Server)
14 * @param id Node to read
15 * @ingroup Read
16 */
17template <typename T>
18Result<NodeId> readNodeId(T& connection, const NodeId& id) noexcept {
20}
21
22/**
23 * @copydoc readNodeId
24 * @param token @completiontoken{void(Result<NodeId>&)}
25 * @return @asyncresult{Result<NodeId>}
26 * @ingroup Read
27 */
28template <typename CompletionToken>
29auto readNodeIdAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
31 connection, id, std::forward<CompletionToken>(token)
32 );
33}
34
35/**
36 * Read the AttributeId::NodeClass attribute of a node.
37 * @param connection Instance of type Client (or Server)
38 * @param id Node to read
39 * @ingroup Read
40 */
41template <typename T>
42Result<NodeClass> readNodeClass(T& connection, const NodeId& id) noexcept {
44}
45
46/**
47 * @copydoc readNodeClass
48 * @param token @completiontoken{void(Result<NodeClass>)}
49 * @return @asyncresult{Result<NodeClass>}
50 * @ingroup Read
51 */
52template <typename CompletionToken>
53auto readNodeClassAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
55 connection, id, std::forward<CompletionToken>(token)
56 );
57}
58
59/**
60 * Read the AttributeId::BrowseName attribute of a node.
61 * @param connection Instance of type Client (or Server)
62 * @param id Node to read
63 * @ingroup Read
64 */
65template <typename T>
66Result<QualifiedName> readBrowseName(T& connection, const NodeId& id) noexcept {
68}
69
70/**
71 * @copydoc readBrowseName
72 * @param token @completiontoken{void(Result<QualifiedName>&)}
73 * @return @asyncresult{Result<QualifiedName>}
74 * @ingroup Read
75 */
76template <typename CompletionToken>
77auto readBrowseNameAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
79 connection, id, std::forward<CompletionToken>(token)
80 );
81}
82
83/**
84 * Write the AttributeId::BrowseName attribute of a node.
85 * @param connection Instance of type Client (or Server)
86 * @param id Node to write
87 * @param browseName Value to write
88 * @ingroup Write
89 */
90template <typename T>
92 T& connection, const NodeId& id, const QualifiedName& browseName
93) noexcept {
94 return detail::writeAttributeImpl<AttributeId::BrowseName>(connection, id, browseName);
95}
96
97/**
98 * @copydoc writeBrowseName
99 * @param token @completiontoken{void(StatusCode)}
100 * @return @asyncresult{StatusCode}
101 * @ingroup Write
102 */
103template <typename CompletionToken>
105 Client& connection, const NodeId& id, const QualifiedName& browseName, CompletionToken&& token
106) {
108 connection, id, browseName, std::forward<CompletionToken>(token)
109 );
110}
111
112/**
113 * Read the AttributeId::DisplayName attribute of a node.
114 * @param connection Instance of type Client (or Server)
115 * @param id Node to read
116 * @ingroup Read
117 */
118template <typename T>
119Result<LocalizedText> readDisplayName(T& connection, const NodeId& id) noexcept {
121}
122
123/**
124 * @copydoc readDisplayName
125 * @param token @completiontoken{void(Result<LocalizedText>&)}
126 * @return @asyncresult{Result<LocalizedText>}
127 * @ingroup Read
128 */
129template <typename CompletionToken>
130auto readDisplayNameAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
132 connection, id, std::forward<CompletionToken>(token)
133 );
134}
135
136/**
137 * Write the AttributeId::DisplayName attribute of a node.
138 * @param connection Instance of type Client (or Server)
139 * @param id Node to write
140 * @param displayName Value to write
141 * @ingroup Write
142 */
143template <typename T>
145 T& connection, const NodeId& id, const LocalizedText& displayName
146) noexcept {
147 return detail::writeAttributeImpl<AttributeId::DisplayName>(connection, id, displayName);
148}
149
150/**
151 * @copydoc writeDisplayName
152 * @param token @completiontoken{void(StatusCode)}
153 * @return @asyncresult{StatusCode}
154 * @ingroup Write
155 */
156template <typename CompletionToken>
158 Client& connection, const NodeId& id, const LocalizedText& displayName, CompletionToken&& token
159) {
161 connection, id, displayName, std::forward<CompletionToken>(token)
162 );
163}
164
165/**
166 * Read the AttributeId::Description attribute of a node.
167 * @param connection Instance of type Client (or Server)
168 * @param id Node to read
169 * @ingroup Read
170 */
171template <typename T>
172Result<LocalizedText> readDescription(T& connection, const NodeId& id) noexcept {
174}
175
176/**
177 * @copydoc readDescription
178 * @param token @completiontoken{void(Result<LocalizedText>&)}
179 * @return @asyncresult{Result<LocalizedText>}
180 * @ingroup Read
181 */
182template <typename CompletionToken>
183auto readDescriptionAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
185 connection, id, std::forward<CompletionToken>(token)
186 );
187}
188
189/**
190 * Write the AttributeId::Description attribute of a node.
191 * @param connection Instance of type Client (or Server)
192 * @param id Node to write
193 * @param description Value to write
194 * @ingroup Write
195 */
196template <typename T>
198 T& connection, const NodeId& id, const LocalizedText& description
199) noexcept {
200 return detail::writeAttributeImpl<AttributeId::Description>(connection, id, description);
201}
202
203/**
204 * @copydoc writeDescription
205 * @param token @completiontoken{void(StatusCode)}
206 * @return @asyncresult{StatusCode}
207 * @ingroup Write
208 */
209template <typename CompletionToken>
211 Client& connection, const NodeId& id, const LocalizedText& description, CompletionToken&& token
212) {
214 connection, id, description, std::forward<CompletionToken>(token)
215 );
216}
217
218/**
219 * Read the AttributeId::WriteMask attribute of a node.
220 * @param connection Instance of type Client (or Server)
221 * @param id Node to read
222 * @ingroup Read
223 */
224template <typename T>
225Result<Bitmask<WriteMask>> readWriteMask(T& connection, const NodeId& id) noexcept {
227}
228
229/**
230 * @copydoc readWriteMask
231 * @param token @completiontoken{void(Result<Bitmask<WriteMask>>)}
232 * @return @asyncresult{Result<Bitmask<WriteMask>>}
233 * @ingroup Read
234 */
235template <typename CompletionToken>
236auto readWriteMaskAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
238 connection, id, std::forward<CompletionToken>(token)
239 );
240}
241
242/**
243 * Write the AttributeId::WriteMask attribute of a node.
244 * @param connection Instance of type Client (or Server)
245 * @param id Node to write
246 * @param writeMask Value to write
247 * @ingroup Write
248 */
249template <typename T>
250StatusCode writeWriteMask(T& connection, const NodeId& id, Bitmask<WriteMask> writeMask) noexcept {
251 return detail::writeAttributeImpl<AttributeId::WriteMask>(connection, id, writeMask);
252}
253
254/**
255 * @copydoc writeWriteMask
256 * @param token @completiontoken{void(StatusCode)}
257 * @return @asyncresult{StatusCode}
258 * @ingroup Write
259 */
260template <typename CompletionToken>
262 Client& connection, const NodeId& id, Bitmask<WriteMask> writeMask, CompletionToken&& token
263) {
265 connection, id, writeMask, std::forward<CompletionToken>(token)
266 );
267}
268
269/**
270 * Read the AttributeId::UserWriteMask attribute of a node.
271 * @param connection Instance of type Client (or Server)
272 * @param id Node to read
273 * @ingroup Read
274 */
275template <typename T>
276Result<Bitmask<WriteMask>> readUserWriteMask(T& connection, const NodeId& id) noexcept {
278}
279
280/**
281 * @copydoc readUserWriteMask
282 * @param token @completiontoken{void(Result<Bitmask<WriteMask>>)}
283 * @return @asyncresult{Result<Bitmask<WriteMask>>}
284 * @ingroup Read
285 */
286template <typename CompletionToken>
287auto readUserWriteMaskAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
289 connection, id, std::forward<CompletionToken>(token)
290 );
291}
292
293/**
294 * Write the AttributeId::UserWriteMask attribute of a node.
295 * @param connection Instance of type Client (or Server)
296 * @param id Node to write
297 * @param userWriteMask Value to write
298 * @ingroup Write
299 */
300template <typename T>
302 T& connection, const NodeId& id, Bitmask<WriteMask> userWriteMask
303) noexcept {
304 return detail::writeAttributeImpl<AttributeId::UserWriteMask>(connection, id, userWriteMask);
305}
306
307/**
308 * @copydoc writeUserWriteMask
309 * @param token @completiontoken{void(StatusCode)}
310 * @return @asyncresult{StatusCode}
311 * @ingroup Write
312 */
313template <typename CompletionToken>
315 Client& connection, const NodeId& id, Bitmask<WriteMask> userWriteMask, CompletionToken&& token
316) {
318 connection, id, userWriteMask, std::forward<CompletionToken>(token)
319 );
320}
321
322/**
323 * Read the AttributeId::IsAbstract attribute of a node.
324 * @param connection Instance of type Client (or Server)
325 * @param id Node to read
326 * @ingroup Read
327 */
328template <typename T>
329Result<bool> readIsAbstract(T& connection, const NodeId& id) noexcept {
331}
332
333/**
334 * @copydoc readIsAbstract
335 * @param token @completiontoken{void(Result<bool>)}
336 * @return @asyncresult{Result<bool>}
337 * @ingroup Read
338 */
339template <typename CompletionToken>
340auto readIsAbstractAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
342 connection, id, std::forward<CompletionToken>(token)
343 );
344}
345
346/**
347 * Write the AttributeId::IsAbstract attribute of a node.
348 * @param connection Instance of type Client (or Server)
349 * @param id Node to write
350 * @param isAbstract Value to write
351 * @ingroup Write
352 */
353template <typename T>
354StatusCode writeIsAbstract(T& connection, const NodeId& id, bool isAbstract) noexcept {
355 return detail::writeAttributeImpl<AttributeId::IsAbstract>(connection, id, isAbstract);
356}
357
358/**
359 * @copydoc writeIsAbstract
360 * @param token @completiontoken{void(StatusCode)}
361 * @return @asyncresult{StatusCode}
362 * @ingroup Write
363 */
364template <typename CompletionToken>
366 Client& connection, const NodeId& id, bool isAbstract, CompletionToken&& token
367) {
369 connection, id, isAbstract, std::forward<CompletionToken>(token)
370 );
371}
372
373/**
374 * Read the AttributeId::Symmetric attribute of a node.
375 * @param connection Instance of type Client (or Server)
376 * @param id Node to read
377 * @ingroup Read
378 */
379template <typename T>
380Result<bool> readSymmetric(T& connection, const NodeId& id) noexcept {
382}
383
384/**
385 * @copydoc readSymmetric
386 * @param token @completiontoken{void(Result<bool>)}
387 * @return @asyncresult{Result<bool>}
388 * @ingroup Read
389 */
390template <typename CompletionToken>
391auto readSymmetricAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
393 connection, id, std::forward<CompletionToken>(token)
394 );
395}
396
397/**
398 * Write the AttributeId::Symmetric attribute of a node.
399 * @param connection Instance of type Client (or Server)
400 * @param id Node to write
401 * @param symmetric Value to write
402 * @ingroup Write
403 */
404template <typename T>
405StatusCode writeSymmetric(T& connection, const NodeId& id, bool symmetric) noexcept {
407}
408
409/**
410 * @copydoc writeSymmetric
411 * @param token @completiontoken{void(StatusCode)}
412 * @return @asyncresult{StatusCode}
413 * @ingroup Write
414 */
415template <typename CompletionToken>
417 Client& connection, const NodeId& id, bool symmetric, CompletionToken&& token
418) {
420 connection, id, symmetric, std::forward<CompletionToken>(token)
421 );
422}
423
424/**
425 * Read the AttributeId::InverseName attribute of a node.
426 * @param connection Instance of type Client (or Server)
427 * @param id Node to read
428 * @ingroup Read
429 */
430template <typename T>
431Result<LocalizedText> readInverseName(T& connection, const NodeId& id) noexcept {
433}
434
435/**
436 * @copydoc readInverseName
437 * @param token @completiontoken{void(Result<LocalizedText>&)}
438 * @return @asyncresult{Result<LocalizedText>}
439 * @ingroup Read
440 */
441template <typename CompletionToken>
442auto readInverseNameAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
444 connection, id, std::forward<CompletionToken>(token)
445 );
446}
447
448/**
449 * Write the AttributeId::InverseName attribute of a node.
450 * @param connection Instance of type Client (or Server)
451 * @param id Node to write
452 * @param inverseName Value to write
453 * @ingroup Write
454 */
455template <typename T>
457 T& connection, const NodeId& id, const LocalizedText& inverseName
458) noexcept {
459 return detail::writeAttributeImpl<AttributeId::InverseName>(connection, id, inverseName);
460}
461
462/**
463 * @copydoc writeInverseName
464 * @param token @completiontoken{void(StatusCode)}
465 * @return @asyncresult{StatusCode}
466 * @ingroup Write
467 */
468template <typename CompletionToken>
470 Client& connection, const NodeId& id, const LocalizedText& inverseName, CompletionToken&& token
471) {
473 connection, id, inverseName, std::forward<CompletionToken>(token)
474 );
475}
476
477/**
478 * Read the AttributeId::ContainsNoLoops attribute of a node.
479 * @param connection Instance of type Client (or Server)
480 * @param id Node to read
481 * @ingroup Read
482 */
483template <typename T>
484Result<bool> readContainsNoLoops(T& connection, const NodeId& id) noexcept {
486}
487
488/**
489 * @copydoc readContainsNoLoops
490 * @param token @completiontoken{void(Result<bool>&)}
491 * @return @asyncresult{Result<bool>}
492 * @ingroup Read
493 */
494template <typename CompletionToken>
495auto readContainsNoLoopsAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
497 connection, id, std::forward<CompletionToken>(token)
498 );
499}
500
501/**
502 * Write the AttributeId::ContainsNoLoops attribute of a node.
503 * @param connection Instance of type Client (or Server)
504 * @param id Node to write
505 * @param containsNoLoops Value to write
506 * @ingroup Write
507 */
508template <typename T>
510 T& connection, const NodeId& id, const bool& containsNoLoops
511) noexcept {
513 connection, id, containsNoLoops
514 );
515}
516
517/**
518 * @copydoc writeContainsNoLoops
519 * @param token @completiontoken{void(StatusCode)}
520 * @return @asyncresult{StatusCode}
521 * @ingroup Write
522 */
523template <typename CompletionToken>
525 Client& connection, const NodeId& id, const bool& containsNoLoops, CompletionToken&& token
526) {
528 connection, id, containsNoLoops, std::forward<CompletionToken>(token)
529 );
530}
531
532/**
533 * Read the AttributeId::EventNotifier attribute of a node.
534 * @param connection Instance of type Client (or Server)
535 * @param id Node to read
536 * @ingroup Read
537 */
538template <typename T>
539Result<Bitmask<EventNotifier>> readEventNotifier(T& connection, const NodeId& id) noexcept {
541}
542
543/**
544 * @copydoc readEventNotifier
545 * @param token @completiontoken{void(Result<Bitmask<EventNotifier>>)}
546 * @return @asyncresult{Result<Bitmask<EventNotifier>>}
547 * @ingroup Read
548 */
549template <typename CompletionToken>
550auto readEventNotifierAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
552 connection, id, std::forward<CompletionToken>(token)
553 );
554}
555
556/**
557 * Write the AttributeId::EventNotifier attribute of a node.
558 * @param connection Instance of type Client (or Server)
559 * @param id Node to write
560 * @param eventNotifier Value to write
561 * @ingroup Write
562 */
563template <typename T>
565 T& connection, const NodeId& id, Bitmask<EventNotifier> eventNotifier
566) noexcept {
567 return detail::writeAttributeImpl<AttributeId::EventNotifier>(connection, id, eventNotifier);
568}
569
570/**
571 * @copydoc writeEventNotifier
572 * @param token @completiontoken{void(StatusCode)}
573 * @return @asyncresult{StatusCode}
574 * @ingroup Write
575 */
576template <typename CompletionToken>
578 Client& connection,
579 const NodeId& id,
580 Bitmask<EventNotifier> eventNotifier,
581 CompletionToken&& token
582) {
584 connection, id, eventNotifier, std::forward<CompletionToken>(token)
585 );
586}
587
588/**
589 * Read the AttributeId::Value attribute of a node.
590 * @param connection Instance of type Client (or Server)
591 * @param id Node to read
592 * @ingroup Read
593 */
594template <typename T>
595Result<Variant> readValue(T& connection, const NodeId& id) noexcept {
597}
598
599/**
600 * @copydoc readValue
601 * @param token @completiontoken{void(Result<Variant>&)}
602 * @return @asyncresult{Result<Variant>}
603 * @ingroup Read
604 */
605template <typename CompletionToken>
606auto readValueAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
608 connection, id, std::forward<CompletionToken>(token)
609 );
610}
611
612/**
613 * Write the AttributeId::Value attribute of a node.
614 * @param connection Instance of type Client (or Server)
615 * @param id Node to write
616 * @param value Value to write
617 * @ingroup Write
618 */
619template <typename T>
620StatusCode writeValue(T& connection, const NodeId& id, const Variant& value) noexcept {
621 return detail::writeAttributeImpl<AttributeId::Value>(connection, id, value);
622}
623
624/**
625 * @copydoc writeValue
626 * @param token @completiontoken{void(StatusCode)}
627 * @return @asyncresult{StatusCode}
628 * @ingroup Write
629 */
630template <typename CompletionToken>
632 Client& connection, const NodeId& id, const Variant& value, CompletionToken&& token
633) {
635 connection, id, value, std::forward<CompletionToken>(token)
636 );
637}
638
639/**
640 * Read the AttributeId::DataType attribute of a node.
641 * @param connection Instance of type Client (or Server)
642 * @param id Node to read
643 * @ingroup Read
644 */
645template <typename T>
646Result<NodeId> readDataType(T& connection, const NodeId& id) noexcept {
648}
649
650/**
651 * @copydoc readDataType
652 * @param token @completiontoken{void(Result<NodeId>&)}
653 * @return @asyncresult{Result<NodeId>}
654 * @ingroup Read
655 */
656template <typename CompletionToken>
657auto readDataTypeAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
659 connection, id, std::forward<CompletionToken>(token)
660 );
661}
662
663/**
664 * Write the AttributeId::DataType attribute of a node.
665 * @param connection Instance of type Client (or Server)
666 * @param id Node to write
667 * @param dataType Value to write
668 * @ingroup Write
669 */
670template <typename T>
671StatusCode writeDataType(T& connection, const NodeId& id, const NodeId& dataType) noexcept {
672 return detail::writeAttributeImpl<AttributeId::DataType>(connection, id, dataType);
673}
674
675/**
676 * @copydoc writeDataType
677 * @param token @completiontoken{void(StatusCode)}
678 * @return @asyncresult{StatusCode}
679 * @ingroup Write
680 */
681template <typename CompletionToken>
683 Client& connection, const NodeId& id, const NodeId& dataType, CompletionToken&& token
684) {
686 connection, id, dataType, std::forward<CompletionToken>(token)
687 );
688}
689
690/**
691 * Read the AttributeId::ValueRank attribute of a node.
692 * @param connection Instance of type Client (or Server)
693 * @param id Node to read
694 * @ingroup Read
695 */
696template <typename T>
697Result<ValueRank> readValueRank(T& connection, const NodeId& id) noexcept {
699}
700
701/**
702 * @copydoc readValueRank
703 * @param token @completiontoken{void(Result<ValueRank>)}
704 * @return @asyncresult{Result<ValueRank>}
705 * @ingroup Read
706 */
707template <typename CompletionToken>
708auto readValueRankAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
710 connection, id, std::forward<CompletionToken>(token)
711 );
712}
713
714/**
715 * Write the AttributeId::ValueRank attribute of a node.
716 * @param connection Instance of type Client (or Server)
717 * @param id Node to write
718 * @param valueRank Value to write
719 * @ingroup Write
720 */
721template <typename T>
722StatusCode writeValueRank(T& connection, const NodeId& id, ValueRank valueRank) noexcept {
723 return detail::writeAttributeImpl<AttributeId::ValueRank>(connection, id, valueRank);
724}
725
726/**
727 * @copydoc writeValueRank
728 * @param token @completiontoken{void(StatusCode)}
729 * @return @asyncresult{StatusCode}
730 * @ingroup Write
731 */
732template <typename CompletionToken>
734 Client& connection, const NodeId& id, ValueRank valueRank, CompletionToken&& token
735) {
737 connection, id, valueRank, std::forward<CompletionToken>(token)
738 );
739}
740
741/**
742 * Read the AttributeId::ArrayDimensions attribute of a node.
743 * @param connection Instance of type Client (or Server)
744 * @param id Node to read
745 * @ingroup Read
746 */
747template <typename T>
748Result<std::vector<uint32_t>> readArrayDimensions(T& connection, const NodeId& id) noexcept {
750}
751
752/**
753 * @copydoc readArrayDimensions
754 * @param token @completiontoken{void(Result<std::vector<uint32_t>>&)}
755 * @return @asyncresult{Result<std::vector<uint32_t>>}
756 * @ingroup Read
757 */
758template <typename CompletionToken>
759auto readArrayDimensionsAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
761 connection, id, std::forward<CompletionToken>(token)
762 );
763}
764
765/**
766 * Write the AttributeId::ArrayDimensions attribute of a node.
767 * @param connection Instance of type Client (or Server)
768 * @param id Node to write
769 * @param arrayDimensions Value to write
770 * @ingroup Write
771 */
772template <typename T>
774 T& connection, const NodeId& id, Span<const uint32_t> arrayDimensions
775) noexcept {
777 connection, id, arrayDimensions
778 );
779}
780
781/**
782 * @copydoc writeArrayDimensions
783 * @param token @completiontoken{void(StatusCode)}
784 * @return @asyncresult{StatusCode}
785 * @ingroup Write
786 */
787template <typename CompletionToken>
789 Client& connection,
790 const NodeId& id,
791 Span<const uint32_t> arrayDimensions,
792 CompletionToken&& token
793) {
795 connection, id, arrayDimensions, std::forward<CompletionToken>(token)
796 );
797}
798
799/**
800 * Read the AttributeId::AccessLevel attribute of a node.
801 * @param connection Instance of type Client (or Server)
802 * @param id Node to read
803 * @ingroup Read
804 */
805template <typename T>
806Result<Bitmask<AccessLevel>> readAccessLevel(T& connection, const NodeId& id) noexcept {
808}
809
810/**
811 * @copydoc readAccessLevel
812 * @param token @completiontoken{void(Result<Bitmask<AccessLevel>>)}
813 * @return @asyncresult{Result<Bitmask<AccessLevel>>}
814 * @ingroup Read
815 */
816template <typename CompletionToken>
817auto readAccessLevelAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
819 connection, id, std::forward<CompletionToken>(token)
820 );
821}
822
823/**
824 * Write the AttributeId::AccessLevel attribute of a node.
825 * @param connection Instance of type Client (or Server)
826 * @param id Node to write
827 * @param accessLevel Value to write
828 * @ingroup Write
829 */
830template <typename T>
832 T& connection, const NodeId& id, Bitmask<AccessLevel> accessLevel
833) noexcept {
834 return detail::writeAttributeImpl<AttributeId::AccessLevel>(connection, id, accessLevel);
835}
836
837/**
838 * @copydoc writeAccessLevel
839 * @param token @completiontoken{void(StatusCode)}
840 * @return @asyncresult{StatusCode}
841 * @ingroup Write
842 */
843template <typename CompletionToken>
845 Client& connection, const NodeId& id, Bitmask<AccessLevel> accessLevel, CompletionToken&& token
846) {
848 connection, id, accessLevel, std::forward<CompletionToken>(token)
849 );
850}
851
852/**
853 * Read the AttributeId::UserAccessLevel attribute of a node.
854 * @param connection Instance of type Client (or Server)
855 * @param id Node to read
856 * @ingroup Read
857 */
858template <typename T>
859Result<Bitmask<AccessLevel>> readUserAccessLevel(T& connection, const NodeId& id) noexcept {
861}
862
863/**
864 * @copydoc readUserAccessLevel
865 * @param token @completiontoken{void(Result<Bitmask<AccessLevel>>)}
866 * @return @asyncresult{Result<Bitmask<AccessLevel>>}
867 * @ingroup Read
868 */
869template <typename CompletionToken>
870auto readUserAccessLevelAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
872 connection, id, std::forward<CompletionToken>(token)
873 );
874}
875
876/**
877 * Write the AttributeId::UserAccessLevel attribute of a node.
878 * @param connection Instance of type Client (or Server)
879 * @param id Node to write
880 * @param userAccessLevel Value to write
881 * @ingroup Write
882 */
883template <typename T>
885 T& connection, const NodeId& id, Bitmask<AccessLevel> userAccessLevel
886) noexcept {
888 connection, id, userAccessLevel
889 );
890}
891
892/**
893 * @copydoc writeUserAccessLevel
894 * @param token @completiontoken{void(StatusCode)}
895 * @return @asyncresult{StatusCode}
896 * @ingroup Write
897 */
898template <typename CompletionToken>
900 Client& connection,
901 const NodeId& id,
902 Bitmask<AccessLevel> userAccessLevel,
903 CompletionToken&& token
904) {
906 connection, id, userAccessLevel, std::forward<CompletionToken>(token)
907 );
908}
909
910/**
911 * Read the AttributeId::MinimumSamplingInterval attribute of a node.
912 * @param connection Instance of type Client (or Server)
913 * @param id Node to read
914 * @ingroup Read
915 */
916template <typename T>
920
921/**
922 * @copydoc readMinimumSamplingInterval
923 * @param token @completiontoken{void(Result<double>)}
924 * @return @asyncresult{Result<double>}
925 * @ingroup Read
926 */
927template <typename CompletionToken>
929 Client& connection, const NodeId& id, CompletionToken&& token
930) {
932 connection, id, std::forward<CompletionToken>(token)
933 );
934}
935
936/**
937 * Write the AttributeId::MinimumSamplingInterval attribute of a node.
938 * @param connection Instance of type Client (or Server)
939 * @param id Node to write
940 * @param minimumSamplingInterval Value to write
941 * @ingroup Write
942 */
943template <typename T>
945 T& connection, const NodeId& id, double minimumSamplingInterval
946) noexcept {
948 connection, id, minimumSamplingInterval
949 );
950}
951
952/**
953 * @copydoc writeMinimumSamplingInterval
954 * @param token @completiontoken{void(StatusCode)}
955 * @return @asyncresult{StatusCode}
956 * @ingroup Write
957 */
958template <typename CompletionToken>
960 Client& connection, const NodeId& id, double minimumSamplingInterval, CompletionToken&& token
961) {
963 connection, id, minimumSamplingInterval, std::forward<CompletionToken>(token)
964 );
965}
966
967/**
968 * Read the AttributeId::Historizing attribute of a node.
969 * @param connection Instance of type Client (or Server)
970 * @param id Node to read
971 * @ingroup Read
972 */
973template <typename T>
974Result<bool> readHistorizing(T& connection, const NodeId& id) noexcept {
976}
977
978/**
979 * @copydoc readHistorizing
980 * @param token @completiontoken{void(Result<bool>)}
981 * @return @asyncresult{Result<bool>}
982 * @ingroup Read
983 */
984template <typename CompletionToken>
985auto readHistorizingAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
987 connection, id, std::forward<CompletionToken>(token)
988 );
989}
990
991/**
992 * Write the AttributeId::Historizing attribute of a node.
993 * @param connection Instance of type Client (or Server)
994 * @param id Node to write
995 * @param historizing Value to write
996 * @ingroup Write
997 */
998template <typename T>
999StatusCode writeHistorizing(T& connection, const NodeId& id, bool historizing) noexcept {
1000 return detail::writeAttributeImpl<AttributeId::Historizing>(connection, id, historizing);
1001}
1002
1003/**
1004 * @copydoc writeHistorizing
1005 * @param token @completiontoken{void(StatusCode)}
1006 * @return @asyncresult{StatusCode}
1007 * @ingroup Write
1008 */
1009template <typename CompletionToken>
1011 Client& connection, const NodeId& id, bool historizing, CompletionToken&& token
1012) {
1014 connection, id, historizing, std::forward<CompletionToken>(token)
1015 );
1016}
1017
1018/**
1019 * Read the AttributeId::Executable attribute of a node.
1020 * @param connection Instance of type Client (or Server)
1021 * @param id Node to read
1022 * @ingroup Read
1023 */
1024template <typename T>
1025Result<bool> readExecutable(T& connection, const NodeId& id) noexcept {
1027}
1028
1029/**
1030 * @copydoc readExecutable
1031 * @param token @completiontoken{void(Result<bool>)}
1032 * @return @asyncresult{Result<bool>}
1033 * @ingroup Read
1034 */
1035template <typename CompletionToken>
1036auto readExecutableAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
1038 connection, id, std::forward<CompletionToken>(token)
1039 );
1040}
1041
1042/**
1043 * Write the AttributeId::Executable attribute of a node.
1044 * @param connection Instance of type Client (or Server)
1045 * @param id Node to write
1046 * @param executable Value to write
1047 * @ingroup Write
1048 */
1049template <typename T>
1050StatusCode writeExecutable(T& connection, const NodeId& id, bool executable) noexcept {
1051 return detail::writeAttributeImpl<AttributeId::Executable>(connection, id, executable);
1052}
1053
1054/**
1055 * @copydoc writeExecutable
1056 * @param token @completiontoken{void(StatusCode)}
1057 * @return @asyncresult{StatusCode}
1058 * @ingroup Write
1059 */
1060template <typename CompletionToken>
1062 Client& connection, const NodeId& id, bool executable, CompletionToken&& token
1063) {
1065 connection, id, executable, std::forward<CompletionToken>(token)
1066 );
1067}
1068
1069/**
1070 * Read the AttributeId::UserExecutable attribute of a node.
1071 * @param connection Instance of type Client (or Server)
1072 * @param id Node to read
1073 * @ingroup Read
1074 */
1075template <typename T>
1076Result<bool> readUserExecutable(T& connection, const NodeId& id) noexcept {
1078}
1079
1080/**
1081 * @copydoc readUserExecutable
1082 * @param token @completiontoken{void(Result<bool>)}
1083 * @return @asyncresult{Result<bool>}
1084 * @ingroup Read
1085 */
1086template <typename CompletionToken>
1087auto readUserExecutableAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
1089 connection, id, std::forward<CompletionToken>(token)
1090 );
1091}
1092
1093/**
1094 * Write the AttributeId::UserExecutable attribute of a node.
1095 * @param connection Instance of type Client (or Server)
1096 * @param id Node to write
1097 * @param userExecutable Value to write
1098 * @ingroup Write
1099 */
1100template <typename T>
1101StatusCode writeUserExecutable(T& connection, const NodeId& id, bool userExecutable) noexcept {
1102 return detail::writeAttributeImpl<AttributeId::UserExecutable>(connection, id, userExecutable);
1103}
1104
1105/**
1106 * @copydoc writeUserExecutable
1107 * @param token @completiontoken{void(StatusCode)}
1108 * @return @asyncresult{StatusCode}
1109 * @ingroup Write
1110 */
1111template <typename CompletionToken>
1113 Client& connection, const NodeId& id, bool userExecutable, CompletionToken&& token
1114) {
1116 connection, id, userExecutable, std::forward<CompletionToken>(token)
1117 );
1118}
1119
1120/**
1121 * Read the AttributeId::DataTypeDefinition attribute of a node.
1122 * The attribute value can be of type EnumDefinition or StructureDefinition.
1123 * @param connection Instance of type Client (or Server)
1124 * @param id Node to read
1125 * @ingroup Read
1126 */
1127template <typename T>
1128Result<Variant> readDataTypeDefinition(T& connection, const NodeId& id) noexcept {
1130}
1131
1132/**
1133 * @copydoc readDataTypeDefinition
1134 * @param token @completiontoken{void(Result<Variant>&)}
1135 * @return @asyncresult{Result<Variant>}
1136 * @ingroup Read
1137 */
1138template <typename CompletionToken>
1139auto readDataTypeDefinitionAsync(Client& connection, const NodeId& id, CompletionToken&& token) {
1141 connection, id, std::forward<CompletionToken>(token)
1142 );
1143}
1144
1145} // namespace opcua::services
Bitmask using (scoped) enums.
Definition bitmask.hpp:125
High-level client class.
Definition client.hpp:121
UA_LocalizedText wrapper class.
Definition types.hpp:837
UA_NodeId wrapper class.
Definition types.hpp:590
UA_QualifiedName wrapper class.
Definition types.hpp:800
The template class Result encapsulates a StatusCode and optionally a value.
Definition result.hpp:53
View to a contiguous sequence of objects, similar to std::span in C++20.
Definition span.hpp:26
UA_StatusCode wrapper class.
Definition types.hpp:44
UA_Variant wrapper class.
Definition types.hpp:887
Result< bool > readContainsNoLoops(T &connection, const NodeId &id) noexcept
Read the AttributeId::ContainsNoLoops attribute of a node.
Result< double > readMinimumSamplingInterval(T &connection, const NodeId &id) noexcept
Read the AttributeId::MinimumSamplingInterval attribute of a node.
Result< NodeId > readDataType(T &connection, const NodeId &id) noexcept
Read the AttributeId::DataType attribute of a node.
Result< bool > readUserExecutable(T &connection, const NodeId &id) noexcept
Read the AttributeId::UserExecutable attribute of a node.
Result< LocalizedText > readInverseName(T &connection, const NodeId &id) noexcept
Read the AttributeId::InverseName attribute of a node.
Result< NodeClass > readNodeClass(T &connection, const NodeId &id) noexcept
Read the AttributeId::NodeClass attribute of a node.
auto readArrayDimensionsAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::ArrayDimensions attribute of a node.
Result< Bitmask< EventNotifier > > readEventNotifier(T &connection, const NodeId &id) noexcept
Read the AttributeId::EventNotifier attribute of a node.
auto readDataTypeDefinitionAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::DataTypeDefinition attribute of a node.
Result< NodeId > readNodeId(T &connection, const NodeId &id) noexcept
Read the AttributeId::NodeId attribute of a node.
Result< Bitmask< WriteMask > > readUserWriteMask(T &connection, const NodeId &id) noexcept
Read the AttributeId::UserWriteMask attribute of a node.
Result< bool > readHistorizing(T &connection, const NodeId &id) noexcept
Read the AttributeId::Historizing attribute of a node.
auto readDescriptionAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::Description attribute of a node.
auto readNodeClassAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::NodeClass attribute of a node.
Result< LocalizedText > readDisplayName(T &connection, const NodeId &id) noexcept
Read the AttributeId::DisplayName attribute of a node.
auto readAccessLevelAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::AccessLevel attribute of a node.
auto readUserExecutableAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::UserExecutable attribute of a node.
Result< QualifiedName > readBrowseName(T &connection, const NodeId &id) noexcept
Read the AttributeId::BrowseName attribute of a node.
auto readEventNotifierAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::EventNotifier attribute of a node.
auto readDisplayNameAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::DisplayName attribute of a node.
Result< bool > readExecutable(T &connection, const NodeId &id) noexcept
Read the AttributeId::Executable attribute of a node.
auto readIsAbstractAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::IsAbstract attribute of a node.
auto readDataTypeAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::DataType attribute of a node.
auto readWriteMaskAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::WriteMask attribute of a node.
auto readUserWriteMaskAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::UserWriteMask attribute of a node.
Result< Variant > readDataTypeDefinition(T &connection, const NodeId &id) noexcept
Read the AttributeId::DataTypeDefinition attribute of a node.
Result< Bitmask< WriteMask > > readWriteMask(T &connection, const NodeId &id) noexcept
Read the AttributeId::WriteMask attribute of a node.
auto readExecutableAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::Executable attribute of a node.
Result< LocalizedText > readDescription(T &connection, const NodeId &id) noexcept
Read the AttributeId::Description attribute of a node.
Result< Variant > readValue(T &connection, const NodeId &id) noexcept
Read the AttributeId::Value attribute of a node.
auto readContainsNoLoopsAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::ContainsNoLoops attribute of a node.
auto readSymmetricAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::Symmetric attribute of a node.
auto readMinimumSamplingIntervalAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::MinimumSamplingInterval attribute of a node.
auto readUserAccessLevelAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::UserAccessLevel attribute of a node.
auto readHistorizingAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::Historizing attribute of a node.
Result< ValueRank > readValueRank(T &connection, const NodeId &id) noexcept
Read the AttributeId::ValueRank attribute of a node.
auto readBrowseNameAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::BrowseName attribute of a node.
Result< bool > readIsAbstract(T &connection, const NodeId &id) noexcept
Read the AttributeId::IsAbstract attribute of a node.
auto readValueAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::Value attribute of a node.
Result< bool > readSymmetric(T &connection, const NodeId &id) noexcept
Read the AttributeId::Symmetric attribute of a node.
Result< Bitmask< AccessLevel > > readUserAccessLevel(T &connection, const NodeId &id) noexcept
Read the AttributeId::UserAccessLevel attribute of a node.
Result< Bitmask< AccessLevel > > readAccessLevel(T &connection, const NodeId &id) noexcept
Read the AttributeId::AccessLevel attribute of a node.
auto readNodeIdAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::NodeId attribute of a node.
Result< std::vector< uint32_t > > readArrayDimensions(T &connection, const NodeId &id) noexcept
Read the AttributeId::ArrayDimensions attribute of a node.
auto readInverseNameAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::InverseName attribute of a node.
auto readValueRankAsync(Client &connection, const NodeId &id, CompletionToken &&token)
Read the AttributeId::ValueRank attribute of a node.
StatusCode writeDataType(T &connection, const NodeId &id, const NodeId &dataType) noexcept
Write the AttributeId::DataType attribute of a node.
StatusCode writeHistorizing(T &connection, const NodeId &id, bool historizing) noexcept
Write the AttributeId::Historizing attribute of a node.
StatusCode writeUserWriteMask(T &connection, const NodeId &id, Bitmask< WriteMask > userWriteMask) noexcept
Write the AttributeId::UserWriteMask attribute of a node.
auto writeAccessLevelAsync(Client &connection, const NodeId &id, Bitmask< AccessLevel > accessLevel, CompletionToken &&token)
Write the AttributeId::AccessLevel attribute of a node.
StatusCode writeContainsNoLoops(T &connection, const NodeId &id, const bool &containsNoLoops) noexcept
Write the AttributeId::ContainsNoLoops attribute of a node.
StatusCode writeArrayDimensions(T &connection, const NodeId &id, Span< const uint32_t > arrayDimensions) noexcept
Write the AttributeId::ArrayDimensions attribute of a node.
auto writeHistorizingAsync(Client &connection, const NodeId &id, bool historizing, CompletionToken &&token)
Write the AttributeId::Historizing attribute of a node.
auto writeBrowseNameAsync(Client &connection, const NodeId &id, const QualifiedName &browseName, CompletionToken &&token)
Write the AttributeId::BrowseName attribute of a node.
auto writeEventNotifierAsync(Client &connection, const NodeId &id, Bitmask< EventNotifier > eventNotifier, CompletionToken &&token)
Write the AttributeId::EventNotifier attribute of a node.
StatusCode writeEventNotifier(T &connection, const NodeId &id, Bitmask< EventNotifier > eventNotifier) noexcept
Write the AttributeId::EventNotifier attribute of a node.
StatusCode writeExecutable(T &connection, const NodeId &id, bool executable) noexcept
Write the AttributeId::Executable attribute of a node.
StatusCode writeIsAbstract(T &connection, const NodeId &id, bool isAbstract) noexcept
Write the AttributeId::IsAbstract attribute of a node.
auto writeArrayDimensionsAsync(Client &connection, const NodeId &id, Span< const uint32_t > arrayDimensions, CompletionToken &&token)
Write the AttributeId::ArrayDimensions attribute of a node.
StatusCode writeValue(T &connection, const NodeId &id, const Variant &value) noexcept
Write the AttributeId::Value attribute of a node.
auto writeContainsNoLoopsAsync(Client &connection, const NodeId &id, const bool &containsNoLoops, CompletionToken &&token)
Write the AttributeId::ContainsNoLoops attribute of a node.
StatusCode writeValueRank(T &connection, const NodeId &id, ValueRank valueRank) noexcept
Write the AttributeId::ValueRank attribute of a node.
auto writeUserWriteMaskAsync(Client &connection, const NodeId &id, Bitmask< WriteMask > userWriteMask, CompletionToken &&token)
Write the AttributeId::UserWriteMask attribute of a node.
auto writeValueRankAsync(Client &connection, const NodeId &id, ValueRank valueRank, CompletionToken &&token)
Write the AttributeId::ValueRank attribute of a node.
StatusCode writeInverseName(T &connection, const NodeId &id, const LocalizedText &inverseName) noexcept
Write the AttributeId::InverseName attribute of a node.
auto writeDataTypeAsync(Client &connection, const NodeId &id, const NodeId &dataType, CompletionToken &&token)
Write the AttributeId::DataType attribute of a node.
auto writeDisplayNameAsync(Client &connection, const NodeId &id, const LocalizedText &displayName, CompletionToken &&token)
Write the AttributeId::DisplayName attribute of a node.
auto writeInverseNameAsync(Client &connection, const NodeId &id, const LocalizedText &inverseName, CompletionToken &&token)
Write the AttributeId::InverseName attribute of a node.
StatusCode writeDescription(T &connection, const NodeId &id, const LocalizedText &description) noexcept
Write the AttributeId::Description attribute of a node.
StatusCode writeDisplayName(T &connection, const NodeId &id, const LocalizedText &displayName) noexcept
Write the AttributeId::DisplayName attribute of a node.
StatusCode writeUserAccessLevel(T &connection, const NodeId &id, Bitmask< AccessLevel > userAccessLevel) noexcept
Write the AttributeId::UserAccessLevel attribute of a node.
StatusCode writeBrowseName(T &connection, const NodeId &id, const QualifiedName &browseName) noexcept
Write the AttributeId::BrowseName attribute of a node.
StatusCode writeMinimumSamplingInterval(T &connection, const NodeId &id, double minimumSamplingInterval) noexcept
Write the AttributeId::MinimumSamplingInterval attribute of a node.
auto writeSymmetricAsync(Client &connection, const NodeId &id, bool symmetric, CompletionToken &&token)
Write the AttributeId::Symmetric attribute of a node.
StatusCode writeWriteMask(T &connection, const NodeId &id, Bitmask< WriteMask > writeMask) noexcept
Write the AttributeId::WriteMask attribute of a node.
auto writeMinimumSamplingIntervalAsync(Client &connection, const NodeId &id, double minimumSamplingInterval, CompletionToken &&token)
Write the AttributeId::MinimumSamplingInterval attribute of a node.
StatusCode writeSymmetric(T &connection, const NodeId &id, bool symmetric) noexcept
Write the AttributeId::Symmetric attribute of a node.
StatusCode writeAccessLevel(T &connection, const NodeId &id, Bitmask< AccessLevel > accessLevel) noexcept
Write the AttributeId::AccessLevel attribute of a node.
StatusCode writeUserExecutable(T &connection, const NodeId &id, bool userExecutable) noexcept
Write the AttributeId::UserExecutable attribute of a node.
auto writeValueAsync(Client &connection, const NodeId &id, const Variant &value, CompletionToken &&token)
Write the AttributeId::Value attribute of a node.
auto writeWriteMaskAsync(Client &connection, const NodeId &id, Bitmask< WriteMask > writeMask, CompletionToken &&token)
Write the AttributeId::WriteMask attribute of a node.
auto writeIsAbstractAsync(Client &connection, const NodeId &id, bool isAbstract, CompletionToken &&token)
Write the AttributeId::IsAbstract attribute of a node.
auto writeDescriptionAsync(Client &connection, const NodeId &id, const LocalizedText &description, CompletionToken &&token)
Write the AttributeId::Description attribute of a node.
auto writeUserExecutableAsync(Client &connection, const NodeId &id, bool userExecutable, CompletionToken &&token)
Write the AttributeId::UserExecutable attribute of a node.
auto writeExecutableAsync(Client &connection, const NodeId &id, bool executable, CompletionToken &&token)
Write the AttributeId::Executable attribute of a node.
auto writeUserAccessLevelAsync(Client &connection, const NodeId &id, Bitmask< AccessLevel > userAccessLevel, CompletionToken &&token)
Write the AttributeId::UserAccessLevel attribute of a node.
StatusCode writeAttributeImpl(T &connection, const NodeId &id, U &&value) noexcept
auto readAttributeAsyncImpl(Client &connection, const NodeId &id, CompletionToken &&token)
auto readAttributeImpl(T &connection, const NodeId &id) noexcept
auto writeAttributeAsyncImpl(T &connection, const NodeId &id, U &&value, CompletionToken &&token)
OPC UA services as free functions.
Definition attribute.hpp:22
ValueRank
Value rank.
Definition common.hpp:224
If a reference is symmetric
Definition symmetric.dox:1