//
// LDASTools frameCPP - A library implementing the LIGO/Virgo frame
// specification
//
// Copyright (C) 2019 California Institute of Technology
//
// LDASTools frameCPP is free software; you may redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 (GPLv2) of the
// License or at your discretion, any later version.
//
// LDASTools frameCPP is distributed in the hope that it will be useful, but
// without any warranty or even the implied warranty of merchantability
// or fitness for a particular purpose. See the GNU General Public
// License (GPLv2) for more details.
//
// Neither the names of the California Institute of Technology (Caltech),
// The Massachusetts Institute of Technology (M.I.T), The Laser
// Interferometer Gravitational-Wave Observatory (LIGO), nor the names
// of its contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// You should have received a copy of the licensing terms for this
// software included in the file LICENSE located in the top-level
// directory of this package. If you did not, you can view a copy at
// http://dcc.ligo.org/M1500244/LICENSE
//

#ifndef FrameCPP_UNIVERSAL__IMPL__FrameHData_HH
#define FrameCPP_UNIVERSAL__IMPL__FrameHData_HH

#if defined( __cplusplus )
#if !defined( SWIG )
#include <memory>
#include <vector>

#include "ldastoolsal/types.hh"

#include "framecpp/Common/Container.hh"

#include "framecpp/Universal/FrDetector.hh"
#include "framecpp/Universal/FrEvent.hh"
#include "framecpp/Universal/FrHistory.hh"
#include "framecpp/Universal/FrProcData.hh"
#include "framecpp/Universal/FrRawData.hh"
#include "framecpp/Universal/FrSimData.hh"
#include "framecpp/Universal/FrSimEvent.hh"
#include "framecpp/Universal/FrSummary.hh"
#include "framecpp/Universal/FrTable.hh"
#include "framecpp/Universal/FrVect.hh"

#include "framecpp/Universal/impl/FrObjectMetaData.hh"

#include "framecpp/Universal/impl/GPSTime.hh"

#endif /* ! defined(SWIG) */
#endif /* defined(__cplusplus) */

#define FRAME_H_NAME_TYPE std::string
#define FRAME_H_RUN_TYPE INT_4S
#define FRAME_H_FRAME_TYPE INT_4U
#define FRAME_H_G_TIME_TYPE LDASTools::AL::GPSTime
#define FRAME_H_G_TIME_S_TYPE INT_4U
#define FRAME_H_G_TIME_N_TYPE INT_4U
#define FRAME_H_DT_TYPE REAL_8

#if defined( __cplusplus )
#if !defined( SWIG )

namespace FrameCPP
{
    namespace Universal
    {
        namespace FrameHImpl
        {
            //-------------------------------------------------------------
            /// @note
            /// <ul>
            ///  <li>Changes introduced in Version 9</li>
            ///  <ul>
            ///    <li> Removed ULeapS (INT_2U)
            ///  </ul>
            ///  <li>Changes introduced in Version 8</li>
            ///  <ul>
            ///    <li> Added per object checksum
            ///  </ul>
            ///  <li>Changes introduced in Version 7</li>
            ///  <ul>
            ///  </ul>
            ///  <li>Changes introduced in Version 6</li>
            ///  <ul>
            ///  </ul>
            ///  <li>Changes introduced in Version 5</li>
            ///  <ul>
            ///    <li>Removed localTime
            ///    <li>Removed strain
            ///  </ul>
            ///  <li>Changes introduced in Version 4</li>
            ///  <ul>
            ///    <li>Added dataQuality
            ///    <li>Added auxData
            ///  </ul>
            ///  <li>Changes introduced in Version 3</li>
            ///  <ul>
            ///    <li>Initial release
            ///  </ul>
            /// </ul>
            //-------------------------------------------------------------
#pragma GCC visibility push( default )
            class Data : public Impl::FrObjectMetaData< Data >
            {
            public:
                struct v3
                {
                    using name_type = std::string;
                    using run_type = INT_4U;
                    using frame_type = INT_4U;
                    using GTime_type = GPSTime;
                    using GTimeS_type = INT_4U;
                    using GTimeN_type = INT_4U;
                    using ULeapS_type = INT_2U;
                    using localTime_type = INT_4S;
                    using dt_type = REAL_8;
                    //---------------------------------------------------
                    using rawData_type = boost::shared_ptr< FrRawData >;

                    using type_type =
                        Common::SearchContainer< FrVect, &FrVect::GetName >;
                    using type_iterator = type_type::iterator;
                    using const_type_iterator = type_type::const_iterator;
                    using type_hash_iterator = type_type::hash_iterator;
                    using const_type_hash_iterator =
                        type_type::const_hash_iterator;

                    using user_type =
                        Common::SearchContainer< FrVect, &FrVect::GetName >;
                    using user_iterator = user_type::iterator;
                    using const_user_iterator = user_type::const_iterator;
                    using user_hash_iterator = user_type::hash_iterator;
                    using const_user_hash_iterator =
                        user_type::const_hash_iterator;

                    using detectSim_type =
                        Common::SearchContainer< FrDetector,
                                                 &FrDetector::GetName >;
                    using detectSim_iterator = detectSim_type::iterator;
                    using const_detectSim_iterator =
                        detectSim_type::const_iterator;
                    using detectSim_hash_iterator =
                        detectSim_type::hash_iterator;
                    using const_detectSim_hash_iterator =
                        detectSim_type::const_hash_iterator;

                    using detectProc_type =
                        Common::SearchContainer< FrDetector,
                                                 &FrDetector::GetName >;
                    using detectProc_iterator = detectProc_type::iterator;
                    using const_detectProc_iterator =
                        detectProc_type::const_iterator;
                    using detectProc_hash_iterator =
                        detectProc_type::hash_iterator;
                    using const_detectProc_hash_iterator =
                        detectProc_type::const_hash_iterator;

                    using history_type =
                        Common::SearchContainer< FrHistory,
                                                 &FrHistory::GetName >;
                    using history_iterator = history_type::iterator;
                    using const_history_iterator = history_type::const_iterator;
                    using history_hash_iterator = history_type::hash_iterator;
                    using const_history_hash_iterator =
                        history_type::const_hash_iterator;

                    using procData_type =
                        Common::SearchContainer< FrProcData,
                                                 &FrProcData::GetNameSlow >;
                    using procData_iterator = procData_type::iterator;
                    using const_procData_iterator =
                        procData_type::const_iterator;
                    using procData_hash_iterator = procData_type::hash_iterator;
                    using const_procData_hash_iterator =
                        procData_type::const_hash_iterator;

                    using strain_type =
                        Common::SearchContainer< FrProcData,
                                                 &FrProcData::GetNameSlow >;
                    using strain_iterator = strain_type::iterator;
                    using const_strain_iterator = strain_type::const_iterator;
                    using strain_hash_iterator = strain_type::hash_iterator;
                    using const_strain_hash_iterator =
                        strain_type::const_hash_iterator;

                    using simData_type =
                        Common::SearchContainer< FrSimData,
                                                 &FrSimData::GetNameSlow >;
                    using simData_iterator = simData_type::iterator;
                    using const_simData_iterator = simData_type::const_iterator;
                    using simData_hash_iterator = simData_type::hash_iterator;
                    using const_simData_hash_iterator =
                        simData_type::const_hash_iterator;

                    using trigData_type =
                        Common::SearchContainer< FrEvent,
                                                 &FrEvent::GetNameSlow >;
                    using trigData_iterator = trigData_type::iterator;
                    using const_trigData_iterator =
                        trigData_type::const_iterator;
                    using trigData_hash_iterator = trigData_type::hash_iterator;
                    using const_trigData_hash_iterator =
                        trigData_type::const_hash_iterator;

                    using summaryData_type =
                        Common::SearchContainer< FrSummary,
                                                 &FrSummary::GetName >;
                    using summaryData_iterator = summaryData_type::iterator;
                    using const_summaryData_iterator =
                        summaryData_type::const_iterator;
                    using summaryData_hash_iterator =
                        summaryData_type::hash_iterator;
                    using const_summaryData_hash_iterator =
                        summaryData_type::const_hash_iterator;

                    using auxData_type =
                        Common::SearchContainer< FrVect, &FrVect::GetName >;
                    using auxData_iterator = auxData_type::iterator;
                    using const_auxData_iterator = auxData_type::const_iterator;
                    using auxData_hash_iterator = auxData_type::hash_iterator;
                    using const_auxData_hash_iterator =
                        auxData_type::const_hash_iterator;
                };
                struct v4
                {
                    using name_type = v3::name_type;
                    using run_type = INT_4S;
                    using frame_type = v3::frame_type;
                    using dataQuality_type = INT_4U;
                    using GTime_type = v3::GTime_type;
                    using GTimeS_type = v3::GTimeS_type;
                    using GTimeN_type = v3::GTimeN_type;
                    using ULeapS_type = v3::ULeapS_type;
                    using localTime_type = v3::localTime_type;
                    using dt_type = v3::dt_type;
                    //---------------------------------------------------
                    using rawData_type = v3::rawData_type;

                    using const_type_hash_iterator =
                        v3::const_type_hash_iterator;
                    using const_type_iterator = v3::const_type_iterator;
                    using type_hash_iterator = v3::type_hash_iterator;
                    using type_iterator = v3::type_iterator;
                    using type_type = v3::type_type;

                    using const_user_hash_iterator =
                        v3::const_user_hash_iterator;
                    using const_user_iterator = v3::const_user_iterator;
                    using user_hash_iterator = v3::user_hash_iterator;
                    using user_iterator = v3::user_iterator;
                    using user_type = v3::user_type;

                    using const_detectSim_hash_iterator =
                        v3::const_detectSim_hash_iterator;
                    using const_detectSim_iterator =
                        v3::const_detectSim_iterator;
                    using detectSim_hash_iterator = v3::detectSim_hash_iterator;
                    using detectSim_iterator = v3::detectSim_iterator;
                    using detectSim_type = v3::detectSim_type;

                    using const_detectProc_hash_iterator =
                        v3::const_detectProc_hash_iterator;
                    using const_detectProc_iterator =
                        v3::const_detectProc_iterator;
                    using detectProc_hash_iterator =
                        v3::detectProc_hash_iterator;
                    using detectProc_iterator = v3::detectProc_iterator;
                    using detectProc_type = v3::detectProc_type;

                    using const_history_hash_iterator =
                        v3::const_history_hash_iterator;
                    using const_history_iterator = v3::const_history_iterator;
                    using history_hash_iterator = v3::history_hash_iterator;
                    using history_iterator = v3::history_iterator;
                    using history_type = v3::history_type;

                    using const_procData_hash_iterator =
                        v3::const_procData_hash_iterator;
                    using const_procData_iterator = v3::const_procData_iterator;
                    using procData_hash_iterator = v3::procData_hash_iterator;
                    using procData_iterator = v3::procData_iterator;
                    using procData_type = v3::procData_type;

                    using const_strain_hash_iterator =
                        v3::const_strain_hash_iterator;
                    using const_strain_iterator = v3::const_strain_iterator;
                    using strain_hash_iterator = v3::strain_hash_iterator;
                    using strain_iterator = v3::strain_iterator;
                    using strain_type = v3::strain_type;

                    using const_simData_hash_iterator =
                        v3::const_simData_hash_iterator;
                    using const_simData_iterator = v3::const_simData_iterator;
                    using simData_hash_iterator = v3::simData_hash_iterator;
                    using simData_iterator = v3::simData_iterator;
                    using simData_type = v3::simData_type;

                    using const_trigData_hash_iterator =
                        v3::const_trigData_hash_iterator;
                    using const_trigData_iterator = v3::const_trigData_iterator;
                    using trigData_hash_iterator = v3::trigData_hash_iterator;
                    using trigData_iterator = v3::trigData_iterator;
                    using trigData_type = v3::trigData_type;

                    using simEvent_type =
                        Common::SearchContainer< FrSimEvent,
                                                 &FrSimEvent::GetNameSlow >;
                    using simEvent_iterator = simEvent_type::iterator;
                    using const_simEvent_iterator =
                        simEvent_type::const_iterator;
                    using simEvent_hash_iterator = simEvent_type::hash_iterator;
                    using const_simEvent_hash_iterator =
                        simEvent_type::const_hash_iterator;

                    using const_summaryData_hash_iterator =
                        v3::const_summaryData_hash_iterator;
                    using const_summaryData_iterator =
                        v3::const_summaryData_iterator;
                    using summaryData_hash_iterator =
                        v3::summaryData_hash_iterator;
                    using summaryData_iterator = v3::summaryData_iterator;
                    using summaryData_type = v3::summaryData_type;

                    using auxData_hash_iterator = v3::auxData_hash_iterator;
                    using auxData_iterator = v3::auxData_iterator;
                    using auxData_type = v3::auxData_type;
                    using const_auxData_hash_iterator =
                        v3::const_auxData_hash_iterator;
                    using const_auxData_iterator = v3::const_auxData_iterator;

                    using auxTable_type =
                        Common::SearchContainer< FrTable,
                                                 &FrTable::GetNameSlow >;
                    using auxTable_iterator = auxTable_type::iterator;
                    using const_auxTable_iterator =
                        auxTable_type::const_iterator;
                    using auxTable_hash_iterator = auxTable_type::hash_iterator;
                    using const_auxTable_hash_iterator =
                        auxTable_type::const_hash_iterator;
                };
                struct v5
                {
                    using name_type = v4::name_type;
                    using run_type = v4::run_type;
                    using frame_type = v4::frame_type;
                    using dataQuality_type = v4::dataQuality_type;
                    using GTime_type = v4::GTime_type;
                    using GTimeS_type = v4::GTimeS_type;
                    using GTimeN_type = v4::GTimeN_type;
                    using ULeapS_type = v4::ULeapS_type;
                    using dt_type = v4::dt_type;
                    //---------------------------------------------------
                    using rawData_type = v4::rawData_type;

                    using const_type_hash_iterator =
                        v4::const_type_hash_iterator;
                    using const_type_iterator = v4::const_type_iterator;
                    using type_hash_iterator = v4::type_hash_iterator;
                    using type_iterator = v4::type_iterator;
                    using type_type = v4::type_type;

                    using const_user_hash_iterator =
                        v4::const_user_hash_iterator;
                    using const_user_iterator = v4::const_user_iterator;
                    using user_hash_iterator = v4::user_hash_iterator;
                    using user_iterator = v4::user_iterator;
                    using user_type = v4::user_type;

                    using const_detectSim_hash_iterator =
                        v4::const_detectSim_hash_iterator;
                    using const_detectSim_iterator =
                        v4::const_detectSim_iterator;
                    using detectSim_hash_iterator = v4::detectSim_hash_iterator;
                    using detectSim_iterator = v4::detectSim_iterator;
                    using detectSim_type = v4::detectSim_type;

                    using const_detectProc_hash_iterator =
                        v4::const_detectProc_hash_iterator;
                    using const_detectProc_iterator =
                        v4::const_detectProc_iterator;
                    using detectProc_hash_iterator =
                        v4::detectProc_hash_iterator;
                    using detectProc_iterator = v4::detectProc_iterator;
                    using detectProc_type = v4::detectProc_type;

                    using const_history_hash_iterator =
                        v4::const_history_hash_iterator;
                    using const_history_iterator = v4::const_history_iterator;
                    using history_hash_iterator = v4::history_hash_iterator;
                    using history_iterator = v4::history_iterator;
                    using history_type = v4::history_type;

                    using const_procData_hash_iterator =
                        v4::const_procData_hash_iterator;
                    using const_procData_iterator = v4::const_procData_iterator;
                    using procData_hash_iterator = v4::procData_hash_iterator;
                    using procData_iterator = v4::procData_iterator;
                    using procData_type = v4::procData_type;

                    using const_simData_hash_iterator =
                        v4::const_simData_hash_iterator;
                    using const_simData_iterator = v4::const_simData_iterator;
                    using simData_hash_iterator = v4::simData_hash_iterator;
                    using simData_iterator = v4::simData_iterator;
                    using simData_type = v4::simData_type;

                    using event_type = v4::trigData_type;
                    using const_event_hash_iterator =
                        v4::const_trigData_hash_iterator;
                    using const_event_iterator = v4::const_trigData_iterator;
                    using event_hash_iterator = v4::trigData_hash_iterator;
                    using event_iterator = v4::trigData_iterator;

                    using simEvent_type = v4::simEvent_type;
                    using simEvent_iterator = v4::simEvent_iterator;
                    using const_simEvent_iterator = v4::const_simEvent_iterator;
                    using simEvent_hash_iterator = v4::simEvent_hash_iterator;
                    using const_simEvent_hash_iterator =
                        v4::const_simEvent_hash_iterator;

                    using const_summaryData_hash_iterator =
                        v4::const_summaryData_hash_iterator;
                    using const_summaryData_iterator =
                        v4::const_summaryData_iterator;
                    using summaryData_hash_iterator =
                        v4::summaryData_hash_iterator;
                    using summaryData_iterator = v4::summaryData_iterator;
                    using summaryData_type = v4::summaryData_type;

                    using auxData_hash_iterator = v4::auxData_hash_iterator;
                    using auxData_iterator = v4::auxData_iterator;
                    using auxData_type = v4::auxData_type;
                    using const_auxData_hash_iterator =
                        v4::const_auxData_hash_iterator;
                    using const_auxData_iterator = v4::const_auxData_iterator;

                    using auxTable_type = v4::auxTable_type;
                    using auxTable_iterator = v4::auxTable_iterator;
                    using const_auxTable_iterator = v4::const_auxTable_iterator;
                    using auxTable_hash_iterator = v4::auxTable_hash_iterator;
                    using const_auxTable_hash_iterator =
                        v4::const_auxTable_hash_iterator;
                };
                using v6 = v5;
                using v7 = v6;
                using v8 = v7;
                struct v9
                {
                    using name_type = v8::name_type;
                    using run_type = v8::run_type;
                    using frame_type = v8::frame_type;
                    using dataQuality_type = v8::dataQuality_type;
                    using GTime_type = v8::GTime_type;
                    using GTimeS_type = v8::GTimeS_type;
                    using GTimeN_type = v8::GTimeN_type;
                    using dt_type = v8::dt_type;
                    //---------------------------------------------------
                    using rawData_type = v8::rawData_type;

                    using const_type_hash_iterator =
                        v8::const_type_hash_iterator;
                    using const_type_iterator = v8::const_type_iterator;
                    using type_hash_iterator = v8::type_hash_iterator;
                    using type_iterator = v8::type_iterator;
                    using type_type = v8::type_type;

                    using const_user_hash_iterator =
                        v8::const_user_hash_iterator;
                    using const_user_iterator = v8::const_user_iterator;
                    using user_hash_iterator = v8::user_hash_iterator;
                    using user_iterator = v8::user_iterator;
                    using user_type = v8::user_type;

                    using const_detectSim_hash_iterator =
                        v8::const_detectSim_hash_iterator;
                    using const_detectSim_iterator =
                        v8::const_detectSim_iterator;
                    using detectSim_hash_iterator = v8::detectSim_hash_iterator;
                    using detectSim_iterator = v8::detectSim_iterator;
                    using detectSim_type = v8::detectSim_type;

                    using const_detectProc_hash_iterator =
                        v8::const_detectProc_hash_iterator;
                    using const_detectProc_iterator =
                        v8::const_detectProc_iterator;
                    using detectProc_hash_iterator =
                        v8::detectProc_hash_iterator;
                    using detectProc_iterator = v8::detectProc_iterator;
                    using detectProc_type = v8::detectProc_type;

                    using const_history_hash_iterator =
                        v8::const_history_hash_iterator;
                    using const_history_iterator = v8::const_history_iterator;
                    using history_hash_iterator = v8::history_hash_iterator;
                    using history_iterator = v8::history_iterator;
                    using history_type = v8::history_type;

                    using const_procData_hash_iterator =
                        v8::const_procData_hash_iterator;
                    using const_procData_iterator = v8::const_procData_iterator;
                    using procData_hash_iterator = v8::procData_hash_iterator;
                    using procData_iterator = v8::procData_iterator;
                    using procData_type = v8::procData_type;

                    using const_simData_hash_iterator =
                        v8::const_simData_hash_iterator;
                    using const_simData_iterator = v8::const_simData_iterator;
                    using simData_hash_iterator = v8::simData_hash_iterator;
                    using simData_iterator = v8::simData_iterator;
                    using simData_type = v8::simData_type;

                    using event_type = v8::event_type;
                    using const_event_hash_iterator =
                        v8::const_event_hash_iterator;
                    using const_event_iterator = v8::const_event_iterator;
                    using event_hash_iterator = v8::event_hash_iterator;
                    using event_iterator = v8::event_iterator;

                    using simEvent_type = v8::simEvent_type;
                    using simEvent_iterator = v8::simEvent_iterator;
                    using const_simEvent_iterator = v8::const_simEvent_iterator;
                    using simEvent_hash_iterator = v8::simEvent_hash_iterator;
                    using const_simEvent_hash_iterator =
                        v8::const_simEvent_hash_iterator;

                    using const_summaryData_hash_iterator =
                        v8::const_summaryData_hash_iterator;
                    using const_summaryData_iterator =
                        v8::const_summaryData_iterator;
                    using summaryData_hash_iterator =
                        v8::summaryData_hash_iterator;
                    using summaryData_iterator = v8::summaryData_iterator;
                    using summaryData_type = v8::summaryData_type;

                    using auxData_hash_iterator = v8::auxData_hash_iterator;
                    using auxData_iterator = v8::auxData_iterator;
                    using auxData_type = v8::auxData_type;
                    using const_auxData_hash_iterator =
                        v8::const_auxData_hash_iterator;
                    using const_auxData_iterator = v8::const_auxData_iterator;

                    using auxTable_type = v8::auxTable_type;
                    using auxTable_iterator = v8::auxTable_iterator;
                    using const_auxTable_iterator = v8::const_auxTable_iterator;
                    using auxTable_hash_iterator = v8::auxTable_hash_iterator;
                    using const_auxTable_hash_iterator =
                        v8::const_auxTable_hash_iterator;
                };
                // ------------------------------------------------------
                using current_version = v9;

                using name_type = current_version::name_type;
                using run_type = current_version::run_type;
                using frame_type = current_version::frame_type;
                using dataQuality_type = current_version::dataQuality_type;
                using GTime_type = current_version::GTime_type;
                using GTimeS_type = current_version::GTimeS_type;
                using GTimeN_type = current_version::GTimeN_type;
                using dt_type = current_version::dt_type;
                //---------------------------------------------------
                using rawData_type = current_version::rawData_type;

                using const_type_hash_iterator =
                    current_version::const_type_hash_iterator;
                using const_type_iterator =
                    current_version::const_type_iterator;
                using type_hash_iterator = current_version::type_hash_iterator;
                using type_iterator = current_version::type_iterator;
                using type_type = current_version::type_type;

                using const_user_hash_iterator =
                    current_version::const_user_hash_iterator;
                using const_user_iterator =
                    current_version::const_user_iterator;
                using user_hash_iterator = current_version::user_hash_iterator;
                using user_iterator = current_version::user_iterator;
                using user_type = current_version::user_type;

                using const_detectSim_hash_iterator =
                    current_version::const_detectSim_hash_iterator;
                using const_detectSim_iterator =
                    current_version::const_detectSim_iterator;
                using detectSim_hash_iterator =
                    current_version::detectSim_hash_iterator;
                using detectSim_iterator = current_version::detectSim_iterator;
                using detectSim_type = current_version::detectSim_type;

                using const_detectProc_hash_iterator =
                    current_version::const_detectProc_hash_iterator;
                using const_detectProc_iterator =
                    current_version::const_detectProc_iterator;
                using detectProc_hash_iterator =
                    current_version::detectProc_hash_iterator;
                using detectProc_iterator =
                    current_version::detectProc_iterator;
                using detectProc_type = current_version::detectProc_type;

                using const_history_hash_iterator =
                    current_version::const_history_hash_iterator;
                using const_history_iterator =
                    current_version::const_history_iterator;
                using history_hash_iterator =
                    current_version::history_hash_iterator;
                using history_iterator = current_version::history_iterator;
                using history_type = current_version::history_type;

                using const_procData_hash_iterator =
                    current_version::const_procData_hash_iterator;
                using const_procData_iterator =
                    current_version::const_procData_iterator;
                using procData_hash_iterator =
                    current_version::procData_hash_iterator;
                using procData_iterator = current_version::procData_iterator;
                using procData_type = current_version::procData_type;

                using const_simData_hash_iterator =
                    current_version::const_simData_hash_iterator;
                using const_simData_iterator =
                    current_version::const_simData_iterator;
                using simData_hash_iterator =
                    current_version::simData_hash_iterator;
                using simData_iterator = current_version::simData_iterator;
                using simData_type = current_version::simData_type;

                using event_type = current_version::event_type;
                using const_event_hash_iterator =
                    current_version::const_event_hash_iterator;
                using const_event_iterator =
                    current_version::const_event_iterator;
                using event_hash_iterator =
                    current_version::event_hash_iterator;
                using event_iterator = current_version::event_iterator;

                using simEvent_type = current_version::simEvent_type;
                using simEvent_iterator = current_version::simEvent_iterator;
                using const_simEvent_iterator =
                    current_version::const_simEvent_iterator;
                using simEvent_hash_iterator =
                    current_version::simEvent_hash_iterator;
                using const_simEvent_hash_iterator =
                    current_version::const_simEvent_hash_iterator;

                using const_summaryData_hash_iterator =
                    current_version::const_summaryData_hash_iterator;
                using const_summaryData_iterator =
                    current_version::const_summaryData_iterator;
                using summaryData_hash_iterator =
                    current_version::summaryData_hash_iterator;
                using summaryData_iterator =
                    current_version::summaryData_iterator;
                using summaryData_type = current_version::summaryData_type;

                using auxData_hash_iterator =
                    current_version::auxData_hash_iterator;
                using auxData_iterator = current_version::auxData_iterator;
                using auxData_type = current_version::auxData_type;
                using const_auxData_hash_iterator =
                    current_version::const_auxData_hash_iterator;
                using const_auxData_iterator =
                    current_version::const_auxData_iterator;

                using auxTable_type = current_version::auxTable_type;
                using auxTable_iterator = current_version::auxTable_iterator;
                using const_auxTable_iterator =
                    current_version::const_auxTable_iterator;
                using auxTable_hash_iterator =
                    current_version::auxTable_hash_iterator;
                using const_auxTable_hash_iterator =
                    current_version::const_auxTable_hash_iterator;
                //-------------------------------------------------------

                inline rawData_type*
                AddressOfRawData( ) const
                {
                    return ( const_cast< rawData_type* >( &rawData ) );
                }

                //-----------------------------------------------------------------
                /// \brief Retrieve name of project
                ///
                /// Retrieve the name of project or other experiment
                /// description.
                ///
                /// \return
                ///     Name of project
                //-----------------------------------------------------------------
                const name_type&
                GetName( ) const
                {
                    return name;
                }

                //-----------------------------------------------------------------
                /// \brief Run number
                ///
                /// Retrieve the run number associated with the frame.
                ///
                /// \return
                ///     The run number of the frame
                //-----------------------------------------------------------------
                run_type
                GetRun( ) const
                {
                    return run;
                }

                //-----------------------------------------------------------------
                /// \brief Frame number
                ///
                /// Retrieve the frame number associated with the frame
                ///
                /// \return
                ///     The frame number of the frame
                //-----------------------------------------------------------------
                frame_type
                GetFrame( ) const
                {
                    return frame;
                }

                //-----------------------------------------------------------------
                /// \brief Data quality flag
                ///
                /// Retrieve the data quality flag associated with the frame
                ///
                /// \return
                ///     The data quality flag for the frame
                //-----------------------------------------------------------------
                dataQuality_type
                GetDataQuality( ) const
                {
                    return dataQuality;
                }

                //-----------------------------------------------------------------
                /// \brief Start Time
                ///
                /// Retrieve the start time of the frame.
                ///
                /// \return
                ///     The start time of the frame
                //-----------------------------------------------------------------
                const GTime_type&
                GetGTime( ) const
                {
                    return GTime;
                }

                //-----------------------------------------------------------------
                /// \brief Frame length
                ///
                /// Retrieve the duration of the frame in seconds.
                ///
                /// \return
                ///     Length of frame in seconds.
                //-----------------------------------------------------------------
                dt_type
                GetDt( ) const
                {
                    return dt;
                }

                //-----------------------------------------------------------------
                /// \brief Establish the name
                ///
                /// Set the project name of the frame.
                /// Values less than zero are reserved for simulated data.
                /// For experimental runs, this value is monotonicly increasing.
                ///
                /// \param[in] Name
                ///     The name to associate with the frame
                //-----------------------------------------------------------------
                void
                SetName( const name_type& Name )
                {
                    name = Name;
                }

                //-----------------------------------------------------------------
                /// \brief Establish the run number
                ///
                /// Set the run number of the frame.
                /// Values less than zero are reserved for simulated data.
                /// For experimental runs, this value is monotonicly increasing.
                ///
                /// \param[in] Run
                ///     The run number to associate with the frame.
                //-----------------------------------------------------------------
                void
                SetRun( run_type Run )
                {
                    run = Run;
                }

                //-----------------------------------------------------------------
                /// \brief Establish the frame number
                ///
                /// Set the frame number.
                /// Frame numbers typically increment within a run.
                ///
                /// \param[in] Frame
                ///     The frame number to associate with the frame.
                //-----------------------------------------------------------------
                void
                SetFrame( frame_type Frame )
                {
                    frame = Frame;
                }

                //-----------------------------------------------------------------
                /// \brief Establish the data quality flag
                ///
                /// Set the data quality flag of the frame.
                ///
                /// \param[in] DataQuality
                ///     The value of the data quality flag.
                //-----------------------------------------------------------------
                void
                SetDataQuality( dataQuality_type DataQuality )
                {
                    dataQuality = DataQuality;
                }

                //-----------------------------------------------------------------
                /// \brief Establish the frame duration.
                ///
                /// Set the length of the frame in seconds.
                ///
                /// \param[in] Dt
                ///     The length of the frame in seconds
                //-----------------------------------------------------------------
                void
                SetDt( dt_type Dt )
                {
                    dt = Dt;
                }

                //-----------------------------------------------------------------
                /// \brief Establish the start time.
                ///
                /// Set the start time of the frame.
                ///
                /// \param[in] Value
                ///     The start time of the frame.
                //-----------------------------------------------------------------
                void
                SetGTime( const GTime_type& Value )
                {
                    GTime = Value;
                }

                //-----------------------------------------------------------------
                /// \brief Retrieve the raw data reference
                ///
                /// Set the number of leap seconds since GPS epoc.
                ///
                /// \return
                ///     A pointer to the raw data structure.
                //-----------------------------------------------------------------
                inline rawData_type
                GetRawData( ) const
                {
                    return rawData;
                }

                //-----------------------------------------------------------------
                /// \brief Retrieve the raw data reference
                ///
                /// \return
                ///     A pointer to the raw data structure.
                //-----------------------------------------------------------------
                inline rawData_type
                GetRawData( )
                {
                    return rawData;
                }

                inline const type_type&
                RefType( ) const
                {
                    return type;
                }

                inline type_type&
                RefType( )
                {
                    return type;
                }

                inline const user_type&
                RefUser( ) const
                {
                    return user;
                }

                inline user_type&
                RefUser( )
                {
                    return user;
                }

                inline const detectSim_type&
                RefDetectSim( ) const
                {
                    return detectSim;
                }

                inline detectSim_type&
                RefDetectSim( )
                {
                    return detectSim;
                }

                inline const detectProc_type&
                RefDetectProc( ) const
                {
                    return detectProc;
                }

                inline detectProc_type&
                RefDetectProc( )
                {
                    return detectProc;
                }

                inline const history_type&
                RefHistory( ) const
                {
                    return history;
                }

                inline history_type&
                RefHistory( )
                {
                    return history;
                }

                inline const procData_type&
                RefProcData( ) const
                {
                    return procData;
                }

                inline procData_type&
                RefProcData( )
                {
                    return procData;
                }

                inline const simData_type&
                RefSimData( ) const
                {
                    return simData;
                }

                inline simData_type&
                RefSimData( )
                {
                    return simData;
                }

                inline const event_type&
                RefEvent( ) const
                {
                    return event;
                }

                inline event_type&
                RefEvent( )
                {
                    return event;
                }

                inline const simEvent_type&
                RefSimEvent( ) const
                {
                    return simEvent;
                }

                inline simEvent_type&
                RefSimEvent( )
                {
                    return simEvent;
                }

                inline const summaryData_type&
                RefSummaryData( ) const
                {
                    return summaryData;
                }

                inline summaryData_type&
                RefSummaryData( )
                {
                    return summaryData;
                }

                inline const auxData_type&
                RefAuxData( ) const
                {
                    return auxData;
                }

                inline auxData_type&
                RefAuxData( )
                {
                    return auxData;
                }

                inline const auxTable_type&
                RefAuxTable( ) const
                {
                    return auxTable;
                }

                inline auxTable_type&
                RefAuxTable( )
                {
                    return auxTable;
                }

                inline void
                SetRawData( rawData_type r )
                {
                    rawData = r;
                }

                inline bool
                operator==( const Data& RHS ) const
                {
                    return ( ( this == &RHS ) ||
                             ( ( name.compare( RHS.name ) == 0 ) &&
                               ( run == RHS.run ) && ( frame == RHS.frame ) &&
                               ( dataQuality == RHS.dataQuality ) &&
                               ( GTime == RHS.GTime ) && ( dt == RHS.dt ) ) );
                }

            protected:
                //-------------------------------------------------------
                name_type        name;
                run_type         run;
                frame_type       frame;
                dataQuality_type dataQuality;
                GTime_type       GTime;
                dt_type          dt;
                //-------------------------------------------------------
                type_type            type;
                user_type            user;
                detectSim_type       detectSim;
                detectProc_type      detectProc;
                mutable history_type history;
                rawData_type         rawData;
                procData_type        procData;
                simData_type         simData;
                event_type           event;
                simEvent_type        simEvent;
                summaryData_type     summaryData;
                auxData_type         auxData;
                auxTable_type        auxTable;
            };
#pragma GCC visibility pop

        }; // namespace FrameHImpl
    } // namespace Universal
} // namespace FrameCPP

FR_OBJECT_META_DATA_DECLARE_UNIVERSAL( FrameHImpl )

#endif /* ! defined(SWIG) */
#endif /* defined(__cplusplus) */

#endif /* FrameCPP_UNIVERSAL__IMPL__FrameHData_HH */
