[Gdcm-hackers] gdcm-git:Grassroots DICOM branch master updated. 28508b82afad3bb270428afff701f788e7f
Cross-platform DICOM implementation
Brought to you by:
malat
|
From: Mathieu M. <ma...@us...> - 2019-04-25 10:22:40
|
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "Grassroots DICOM".
The branch, master has been updated
via 28508b82afad3bb270428afff701f788e7ff6a6b (commit)
via 5aeeeb180526d558b3d1efcc6a50dadcfbb2e02f (commit)
from a1d26a5c9edf4269176f957ffada1deec9de37ba (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
https://sourceforge.net/p/gdcm/gdcm/ci/28508b82afad3bb270428afff701f788e7ff6a6b/
commit 28508b82afad3bb270428afff701f788e7ff6a6b
Author: Mihail Isakov <mih...@gm...>
Date: Thu Apr 25 12:18:03 2019 +0200
Set an explicit underlying type for VRType
Using a sed expression for now:
$ sed -i -e 's/enum { VRType/enum : long long { VRType/g'
diff --git a/Source/DataDictionary/gdcmTagToType.h b/Source/DataDictionary/gdcmTagToType.h
index 175ad8502..4a416c426 100644
--- a/Source/DataDictionary/gdcmTagToType.h
+++ b/Source/DataDictionary/gdcmTagToType.h
@@ -27,25193 +27,25193 @@ namespace gdcm {
// default template: the compiler should only pick it up when the element is private:
template <uint16_t group,uint16_t element> struct TagToType {
//GDCM_STATIC_ASSERT( group % 2 );
-enum { VRType = VR::VRALL };
+enum : long long { VRType = VR::VRALL };
enum { VMType = VM::VM1_n };
};
// template for group length:
template <uint16_t group> struct TagToType<group,0x0000> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0000> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0001> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0002> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0003> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0010> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0100> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0110> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0120> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0200> {
static const char* GetVRString() { return "AE"; }
typedef VRToType<VR::AE>::Type Type;
-enum { VRType = VR::AE };
+enum : long long { VRType = VR::AE };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0300> {
static const char* GetVRString() { return "AE"; }
typedef VRToType<VR::AE>::Type Type;
-enum { VRType = VR::AE };
+enum : long long { VRType = VR::AE };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0400> {
static const char* GetVRString() { return "AE"; }
typedef VRToType<VR::AE>::Type Type;
-enum { VRType = VR::AE };
+enum : long long { VRType = VR::AE };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0600> {
static const char* GetVRString() { return "AE"; }
typedef VRToType<VR::AE>::Type Type;
-enum { VRType = VR::AE };
+enum : long long { VRType = VR::AE };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0700> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0800> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0850> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0860> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0900> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0901> {
static const char* GetVRString() { return "AT"; }
typedef VRToType<VR::AT>::Type Type;
-enum { VRType = VR::AT };
+enum : long long { VRType = VR::AT };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0000,0x0902> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x0903> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x1000> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x1001> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x1002> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x1005> {
static const char* GetVRString() { return "AT"; }
typedef VRToType<VR::AT>::Type Type;
-enum { VRType = VR::AT };
+enum : long long { VRType = VR::AT };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0000,0x1008> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x1020> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x1021> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x1022> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x1023> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x1030> {
static const char* GetVRString() { return "AE"; }
typedef VRToType<VR::AE>::Type Type;
-enum { VRType = VR::AE };
+enum : long long { VRType = VR::AE };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x1031> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x4000> {
static const char* GetVRString() { return "LT"; }
typedef VRToType<VR::LT>::Type Type;
-enum { VRType = VR::LT };
+enum : long long { VRType = VR::LT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x4010> {
static const char* GetVRString() { return "LT"; }
typedef VRToType<VR::LT>::Type Type;
-enum { VRType = VR::LT };
+enum : long long { VRType = VR::LT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x5010> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x5020> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x5110> {
static const char* GetVRString() { return "LT"; }
typedef VRToType<VR::LT>::Type Type;
-enum { VRType = VR::LT };
+enum : long long { VRType = VR::LT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x5120> {
static const char* GetVRString() { return "LT"; }
typedef VRToType<VR::LT>::Type Type;
-enum { VRType = VR::LT };
+enum : long long { VRType = VR::LT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x5130> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x5140> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x5150> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x5160> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x5170> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x5180> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x5190> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x51a0> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0000,0x51b0> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0002,0x0000> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0002,0x0001> {
static const char* GetVRString() { return "OB"; }
typedef VRToType<VR::OB>::Type Type;
-enum { VRType = VR::OB };
+enum : long long { VRType = VR::OB };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0002,0x0002> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0002,0x0003> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0002,0x0010> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0002,0x0012> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0002,0x0013> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0002,0x0016> {
static const char* GetVRString() { return "AE"; }
typedef VRToType<VR::AE>::Type Type;
-enum { VRType = VR::AE };
+enum : long long { VRType = VR::AE };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0002,0x0100> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0002,0x0102> {
static const char* GetVRString() { return "OB"; }
typedef VRToType<VR::OB>::Type Type;
-enum { VRType = VR::OB };
+enum : long long { VRType = VR::OB };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0004,0x1130> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0004,0x1141> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1_8 };
static const char* GetVMString() { return "1-8"; }
};
template <> struct TagToType<0x0004,0x1142> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0004,0x1200> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0004,0x1202> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0004,0x1212> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0004,0x1220> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0004,0x1400> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0004,0x1410> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0004,0x1420> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0004,0x1430> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0004,0x1432> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0004,0x1500> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1_8 };
static const char* GetVMString() { return "1-8"; }
};
template <> struct TagToType<0x0004,0x1504> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0004,0x1510> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0004,0x1511> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0004,0x1512> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0004,0x151a> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0004,0x1600> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0001> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0005> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x0006> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0008> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM2_n };
static const char* GetVMString() { return "2-n"; }
};
template <> struct TagToType<0x0008,0x0010> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0012> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
-enum { VRType = VR::DA };
+enum : long long { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0013> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
-enum { VRType = VR::TM };
+enum : long long { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0014> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0016> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0018> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x001a> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x001b> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0020> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
-enum { VRType = VR::DA };
+enum : long long { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0021> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
-enum { VRType = VR::DA };
+enum : long long { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0022> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
-enum { VRType = VR::DA };
+enum : long long { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0023> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
-enum { VRType = VR::DA };
+enum : long long { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0024> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
-enum { VRType = VR::DA };
+enum : long long { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0025> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
-enum { VRType = VR::DA };
+enum : long long { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x002a> {
static const char* GetVRString() { return "DT"; }
typedef VRToType<VR::DT>::Type Type;
-enum { VRType = VR::DT };
+enum : long long { VRType = VR::DT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0030> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
-enum { VRType = VR::TM };
+enum : long long { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0031> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
-enum { VRType = VR::TM };
+enum : long long { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0032> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
-enum { VRType = VR::TM };
+enum : long long { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0033> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
-enum { VRType = VR::TM };
+enum : long long { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0034> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
-enum { VRType = VR::TM };
+enum : long long { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0035> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
-enum { VRType = VR::TM };
+enum : long long { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0040> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0041> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0042> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0050> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0051> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0052> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0054> {
static const char* GetVRString() { return "AE"; }
typedef VRToType<VR::AE>::Type Type;
-enum { VRType = VR::AE };
+enum : long long { VRType = VR::AE };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x0056> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0058> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x0060> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0061> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x0062> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x0064> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0068> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0070> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0080> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0081> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
-enum { VRType = VR::ST };
+enum : long long { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0082> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0090> {
static const char* GetVRString() { return "PN"; }
typedef VRToType<VR::PN>::Type Type;
-enum { VRType = VR::PN };
+enum : long long { VRType = VR::PN };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0092> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
-enum { VRType = VR::ST };
+enum : long long { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0094> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x0096> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0100> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0102> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0103> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0104> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0105> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0106> {
static const char* GetVRString() { return "DT"; }
typedef VRToType<VR::DT>::Type Type;
-enum { VRType = VR::DT };
+enum : long long { VRType = VR::DT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0107> {
static const char* GetVRString() { return "DT"; }
typedef VRToType<VR::DT>::Type Type;
-enum { VRType = VR::DT };
+enum : long long { VRType = VR::DT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x010b> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x010c> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x010d> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x010f> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0110> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0112> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0114> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
-enum { VRType = VR::ST };
+enum : long long { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0115> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
-enum { VRType = VR::ST };
+enum : long long { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0116> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
-enum { VRType = VR::ST };
+enum : long long { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0117> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x0201> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1000> {
static const char* GetVRString() { return "AE"; }
typedef VRToType<VR::AE>::Type Type;
-enum { VRType = VR::AE };
+enum : long long { VRType = VR::AE };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1010> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1030> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1032> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x103e> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x103f> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1040> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1048> {
static const char* GetVRString() { return "PN"; }
typedef VRToType<VR::PN>::Type Type;
-enum { VRType = VR::PN };
+enum : long long { VRType = VR::PN };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x1049> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1050> {
static const char* GetVRString() { return "PN"; }
typedef VRToType<VR::PN>::Type Type;
-enum { VRType = VR::PN };
+enum : long long { VRType = VR::PN };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x1052> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1060> {
static const char* GetVRString() { return "PN"; }
typedef VRToType<VR::PN>::Type Type;
-enum { VRType = VR::PN };
+enum : long long { VRType = VR::PN };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x1062> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1070> {
static const char* GetVRString() { return "PN"; }
typedef VRToType<VR::PN>::Type Type;
-enum { VRType = VR::PN };
+enum : long long { VRType = VR::PN };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x1072> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1080> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x1084> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1090> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1100> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1110> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1111> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1115> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1120> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1125> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1130> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1134> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x113a> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1140> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1145> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x114a> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x114b> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1150> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1155> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x115a> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x1160> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x1161> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x1162> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
enum { VMType = VM::VM3_3n };
static const char* GetVMString() { return "3-3n"; }
};
template <> struct TagToType<0x0008,0x1163> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
-enum { VRType = VR::FD };
+enum : long long { VRType = VR::FD };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
template <> struct TagToType<0x0008,0x1164> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1167> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1195> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1197> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1198> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1199> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1200> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x1250> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2110> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2111> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
-enum { VRType = VR::ST };
+enum : long long { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2112> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2120> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2122> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2124> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2127> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2128> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2129> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x212a> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2130> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
-enum { VRType = VR::DS };
+enum : long long { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x2132> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
template <> struct TagToType<0x0008,0x2133> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2134> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
-enum { VRType = VR::FD };
+enum : long long { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2135> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2142> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2143> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2144> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2200> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2204> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
template <> struct TagToType<0x0008,0x2208> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
enum { VMType = VM::VM1 };
stat...
[truncated message content] |