tokval.cc

Go to the documentation of this file.

// auto-generated tokval implementation
 
#include "tokval.h"
#include "tokval_variant.h"
#include <agenda_class.h>
 
TokVal::TokVal(AbsorptionLines in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<AbsorptionLines>(std::move(in));}
TokVal::TokVal(Agenda in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Agenda>(std::move(in));}
TokVal::TokVal(Any in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Any>(std::move(in));}
TokVal::TokVal(ArrayOfAbsorptionLines in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfAbsorptionLines>(std::move(in));}
TokVal::TokVal(ArrayOfAgenda in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfAgenda>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfAbsorptionLines in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfAbsorptionLines>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfGriddedField1 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfGriddedField1>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfGriddedField2 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfGriddedField2>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfGriddedField3 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfGriddedField3>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfIndex in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfIndex>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfMatrix in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfMatrix>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfPropagationMatrix in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfPropagationMatrix>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfRadiationVector in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfRadiationVector>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfScatteringMetaData in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfScatteringMetaData>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfSingleScatteringData in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfSingleScatteringData>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfSpeciesTag in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfSpeciesTag>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfStokesVector in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfStokesVector>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfString in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfString>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfTensor3 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfTensor3>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfTensor6 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfTensor6>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfTime in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfTime>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfTransmissionMatrix in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfTransmissionMatrix>(std::move(in));}
TokVal::TokVal(ArrayOfArrayOfVector in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfVector>(std::move(in));}
TokVal::TokVal(ArrayOfCIARecord in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfCIARecord>(std::move(in));}
TokVal::TokVal(ArrayOfGriddedField1 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfGriddedField1>(std::move(in));}
TokVal::TokVal(ArrayOfGriddedField2 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfGriddedField2>(std::move(in));}
TokVal::TokVal(ArrayOfGriddedField3 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfGriddedField3>(std::move(in));}
TokVal::TokVal(ArrayOfGriddedField4 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfGriddedField4>(std::move(in));}
TokVal::TokVal(ArrayOfIndex in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfIndex>(std::move(in));}
TokVal::TokVal(ArrayOfJacobianTarget in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfJacobianTarget>(std::move(in));}
TokVal::TokVal(ArrayOfMatrix in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfMatrix>(std::move(in));}
TokVal::TokVal(ArrayOfPpath in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfPpath>(std::move(in));}
TokVal::TokVal(ArrayOfPropagationMatrix in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfPropagationMatrix>(std::move(in));}
TokVal::TokVal(ArrayOfQuantumIdentifier in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfQuantumIdentifier>(std::move(in));}
TokVal::TokVal(ArrayOfRadiationVector in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfRadiationVector>(std::move(in));}
TokVal::TokVal(ArrayOfRetrievalQuantity in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfRetrievalQuantity>(std::move(in));}
TokVal::TokVal(ArrayOfScatteringMetaData in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfScatteringMetaData>(std::move(in));}
TokVal::TokVal(ArrayOfSingleScatteringData in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfSingleScatteringData>(std::move(in));}
TokVal::TokVal(ArrayOfSparse in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfSparse>(std::move(in));}
TokVal::TokVal(ArrayOfSpeciesTag in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfSpeciesTag>(std::move(in));}
TokVal::TokVal(ArrayOfStokesVector in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfStokesVector>(std::move(in));}
TokVal::TokVal(ArrayOfString in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfString>(std::move(in));}
TokVal::TokVal(ArrayOfSun in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfSun>(std::move(in));}
TokVal::TokVal(ArrayOfTelsemAtlas in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfTelsemAtlas>(std::move(in));}
TokVal::TokVal(ArrayOfTensor3 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfTensor3>(std::move(in));}
TokVal::TokVal(ArrayOfTensor4 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfTensor4>(std::move(in));}
TokVal::TokVal(ArrayOfTensor5 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfTensor5>(std::move(in));}
TokVal::TokVal(ArrayOfTensor6 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfTensor6>(std::move(in));}
TokVal::TokVal(ArrayOfTensor7 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfTensor7>(std::move(in));}
TokVal::TokVal(ArrayOfTime in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfTime>(std::move(in));}
TokVal::TokVal(ArrayOfTransmissionMatrix in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfTransmissionMatrix>(std::move(in));}
TokVal::TokVal(ArrayOfVector in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfVector>(std::move(in));}
TokVal::TokVal(ArrayOfXsecRecord in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ArrayOfXsecRecord>(std::move(in));}
TokVal::TokVal(CIARecord in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<CIARecord>(std::move(in));}
TokVal::TokVal(CallbackFunction in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<CallbackFunction>(std::move(in));}
TokVal::TokVal(CovarianceMatrix in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<CovarianceMatrix>(std::move(in));}
TokVal::TokVal(EnergyLevelMap in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<EnergyLevelMap>(std::move(in));}
TokVal::TokVal(GasAbsLookup in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<GasAbsLookup>(std::move(in));}
TokVal::TokVal(GridPos in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<GridPos>(std::move(in));}
TokVal::TokVal(GriddedField1 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<GriddedField1>(std::move(in));}
TokVal::TokVal(GriddedField2 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<GriddedField2>(std::move(in));}
TokVal::TokVal(GriddedField3 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<GriddedField3>(std::move(in));}
TokVal::TokVal(GriddedField4 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<GriddedField4>(std::move(in));}
TokVal::TokVal(GriddedField5 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<GriddedField5>(std::move(in));}
TokVal::TokVal(GriddedField6 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<GriddedField6>(std::move(in));}
TokVal::TokVal(HitranRelaxationMatrixData in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<HitranRelaxationMatrixData>(std::move(in));}
TokVal::TokVal(Index in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Index>(std::move(in));}
TokVal::TokVal(JacobianTarget in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<JacobianTarget>(std::move(in));}
TokVal::TokVal(MCAntenna in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<MCAntenna>(std::move(in));}
TokVal::TokVal(MapOfErrorCorrectedSuddenData in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<MapOfErrorCorrectedSuddenData>(std::move(in));}
TokVal::TokVal(Matrix in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Matrix>(std::move(in));}
TokVal::TokVal(Numeric in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Numeric>(std::move(in));}
TokVal::TokVal(Ppath in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Ppath>(std::move(in));}
TokVal::TokVal(PredefinedModelData in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<PredefinedModelData>(std::move(in));}
TokVal::TokVal(PropagationMatrix in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<PropagationMatrix>(std::move(in));}
TokVal::TokVal(QuantumIdentifier in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<QuantumIdentifier>(std::move(in));}
TokVal::TokVal(RadiationVector in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<RadiationVector>(std::move(in));}
TokVal::TokVal(Rational in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Rational>(std::move(in));}
TokVal::TokVal(ScatteringMetaData in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<ScatteringMetaData>(std::move(in));}
TokVal::TokVal(SingleScatteringData in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<SingleScatteringData>(std::move(in));}
TokVal::TokVal(Sparse in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Sparse>(std::move(in));}
TokVal::TokVal(SpeciesIsotopologueRatios in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<SpeciesIsotopologueRatios>(std::move(in));}
TokVal::TokVal(SpectralRadianceProfileOperator in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<SpectralRadianceProfileOperator>(std::move(in));}
TokVal::TokVal(StokesVector in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<StokesVector>(std::move(in));}
TokVal::TokVal(String in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<String>(std::move(in));}
TokVal::TokVal(TelsemAtlas in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<TelsemAtlas>(std::move(in));}
TokVal::TokVal(Tensor3 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Tensor3>(std::move(in));}
TokVal::TokVal(Tensor4 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Tensor4>(std::move(in));}
TokVal::TokVal(Tensor5 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Tensor5>(std::move(in));}
TokVal::TokVal(Tensor6 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Tensor6>(std::move(in));}
TokVal::TokVal(Tensor7 in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Tensor7>(std::move(in));}
TokVal::TokVal(TessemNN in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<TessemNN>(std::move(in));}
TokVal::TokVal(Time in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Time>(std::move(in));}
TokVal::TokVal(Timer in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Timer>(std::move(in));}
TokVal::TokVal(TransmissionMatrix in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<TransmissionMatrix>(std::move(in));}
TokVal::TokVal(Vector in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Vector>(std::move(in));}
TokVal::TokVal(Verbosity in) : ptr(static_cast<void*>(new TokValType{std::make_unique<Any>()})) {*tokval_type(ptr) = std::make_unique<Verbosity>(std::move(in));}
 
TokVal& TokVal::operator=(AbsorptionLines in) {*tokval_type(ptr) = std::make_unique<AbsorptionLines>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Agenda in) {*tokval_type(ptr) = std::make_unique<Agenda>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Any in) {*tokval_type(ptr) = std::make_unique<Any>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfAbsorptionLines in) {*tokval_type(ptr) = std::make_unique<ArrayOfAbsorptionLines>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfAgenda in) {*tokval_type(ptr) = std::make_unique<ArrayOfAgenda>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfAbsorptionLines in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfAbsorptionLines>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfGriddedField1 in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfGriddedField1>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfGriddedField2 in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfGriddedField2>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfGriddedField3 in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfGriddedField3>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfIndex in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfIndex>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfMatrix in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfMatrix>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfPropagationMatrix in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfPropagationMatrix>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfRadiationVector in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfRadiationVector>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfScatteringMetaData in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfScatteringMetaData>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfSingleScatteringData in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfSingleScatteringData>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfSpeciesTag in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfSpeciesTag>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfStokesVector in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfStokesVector>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfString in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfString>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfTensor3 in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfTensor3>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfTensor6 in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfTensor6>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfTime in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfTime>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfTransmissionMatrix in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfTransmissionMatrix>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfArrayOfVector in) {*tokval_type(ptr) = std::make_unique<ArrayOfArrayOfVector>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfCIARecord in) {*tokval_type(ptr) = std::make_unique<ArrayOfCIARecord>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfGriddedField1 in) {*tokval_type(ptr) = std::make_unique<ArrayOfGriddedField1>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfGriddedField2 in) {*tokval_type(ptr) = std::make_unique<ArrayOfGriddedField2>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfGriddedField3 in) {*tokval_type(ptr) = std::make_unique<ArrayOfGriddedField3>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfGriddedField4 in) {*tokval_type(ptr) = std::make_unique<ArrayOfGriddedField4>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfIndex in) {*tokval_type(ptr) = std::make_unique<ArrayOfIndex>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfJacobianTarget in) {*tokval_type(ptr) = std::make_unique<ArrayOfJacobianTarget>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfMatrix in) {*tokval_type(ptr) = std::make_unique<ArrayOfMatrix>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfPpath in) {*tokval_type(ptr) = std::make_unique<ArrayOfPpath>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfPropagationMatrix in) {*tokval_type(ptr) = std::make_unique<ArrayOfPropagationMatrix>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfQuantumIdentifier in) {*tokval_type(ptr) = std::make_unique<ArrayOfQuantumIdentifier>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfRadiationVector in) {*tokval_type(ptr) = std::make_unique<ArrayOfRadiationVector>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfRetrievalQuantity in) {*tokval_type(ptr) = std::make_unique<ArrayOfRetrievalQuantity>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfScatteringMetaData in) {*tokval_type(ptr) = std::make_unique<ArrayOfScatteringMetaData>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfSingleScatteringData in) {*tokval_type(ptr) = std::make_unique<ArrayOfSingleScatteringData>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfSparse in) {*tokval_type(ptr) = std::make_unique<ArrayOfSparse>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfSpeciesTag in) {*tokval_type(ptr) = std::make_unique<ArrayOfSpeciesTag>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfStokesVector in) {*tokval_type(ptr) = std::make_unique<ArrayOfStokesVector>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfString in) {*tokval_type(ptr) = std::make_unique<ArrayOfString>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfSun in) {*tokval_type(ptr) = std::make_unique<ArrayOfSun>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfTelsemAtlas in) {*tokval_type(ptr) = std::make_unique<ArrayOfTelsemAtlas>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfTensor3 in) {*tokval_type(ptr) = std::make_unique<ArrayOfTensor3>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfTensor4 in) {*tokval_type(ptr) = std::make_unique<ArrayOfTensor4>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfTensor5 in) {*tokval_type(ptr) = std::make_unique<ArrayOfTensor5>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfTensor6 in) {*tokval_type(ptr) = std::make_unique<ArrayOfTensor6>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfTensor7 in) {*tokval_type(ptr) = std::make_unique<ArrayOfTensor7>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfTime in) {*tokval_type(ptr) = std::make_unique<ArrayOfTime>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfTransmissionMatrix in) {*tokval_type(ptr) = std::make_unique<ArrayOfTransmissionMatrix>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfVector in) {*tokval_type(ptr) = std::make_unique<ArrayOfVector>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ArrayOfXsecRecord in) {*tokval_type(ptr) = std::make_unique<ArrayOfXsecRecord>(std::move(in)); return *this;}
TokVal& TokVal::operator=(CIARecord in) {*tokval_type(ptr) = std::make_unique<CIARecord>(std::move(in)); return *this;}
TokVal& TokVal::operator=(CallbackFunction in) {*tokval_type(ptr) = std::make_unique<CallbackFunction>(std::move(in)); return *this;}
TokVal& TokVal::operator=(CovarianceMatrix in) {*tokval_type(ptr) = std::make_unique<CovarianceMatrix>(std::move(in)); return *this;}
TokVal& TokVal::operator=(EnergyLevelMap in) {*tokval_type(ptr) = std::make_unique<EnergyLevelMap>(std::move(in)); return *this;}
TokVal& TokVal::operator=(GasAbsLookup in) {*tokval_type(ptr) = std::make_unique<GasAbsLookup>(std::move(in)); return *this;}
TokVal& TokVal::operator=(GridPos in) {*tokval_type(ptr) = std::make_unique<GridPos>(std::move(in)); return *this;}
TokVal& TokVal::operator=(GriddedField1 in) {*tokval_type(ptr) = std::make_unique<GriddedField1>(std::move(in)); return *this;}
TokVal& TokVal::operator=(GriddedField2 in) {*tokval_type(ptr) = std::make_unique<GriddedField2>(std::move(in)); return *this;}
TokVal& TokVal::operator=(GriddedField3 in) {*tokval_type(ptr) = std::make_unique<GriddedField3>(std::move(in)); return *this;}
TokVal& TokVal::operator=(GriddedField4 in) {*tokval_type(ptr) = std::make_unique<GriddedField4>(std::move(in)); return *this;}
TokVal& TokVal::operator=(GriddedField5 in) {*tokval_type(ptr) = std::make_unique<GriddedField5>(std::move(in)); return *this;}
TokVal& TokVal::operator=(GriddedField6 in) {*tokval_type(ptr) = std::make_unique<GriddedField6>(std::move(in)); return *this;}
TokVal& TokVal::operator=(HitranRelaxationMatrixData in) {*tokval_type(ptr) = std::make_unique<HitranRelaxationMatrixData>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Index in) {*tokval_type(ptr) = std::make_unique<Index>(std::move(in)); return *this;}
TokVal& TokVal::operator=(JacobianTarget in) {*tokval_type(ptr) = std::make_unique<JacobianTarget>(std::move(in)); return *this;}
TokVal& TokVal::operator=(MCAntenna in) {*tokval_type(ptr) = std::make_unique<MCAntenna>(std::move(in)); return *this;}
TokVal& TokVal::operator=(MapOfErrorCorrectedSuddenData in) {*tokval_type(ptr) = std::make_unique<MapOfErrorCorrectedSuddenData>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Matrix in) {*tokval_type(ptr) = std::make_unique<Matrix>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Numeric in) {*tokval_type(ptr) = std::make_unique<Numeric>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Ppath in) {*tokval_type(ptr) = std::make_unique<Ppath>(std::move(in)); return *this;}
TokVal& TokVal::operator=(PredefinedModelData in) {*tokval_type(ptr) = std::make_unique<PredefinedModelData>(std::move(in)); return *this;}
TokVal& TokVal::operator=(PropagationMatrix in) {*tokval_type(ptr) = std::make_unique<PropagationMatrix>(std::move(in)); return *this;}
TokVal& TokVal::operator=(QuantumIdentifier in) {*tokval_type(ptr) = std::make_unique<QuantumIdentifier>(std::move(in)); return *this;}
TokVal& TokVal::operator=(RadiationVector in) {*tokval_type(ptr) = std::make_unique<RadiationVector>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Rational in) {*tokval_type(ptr) = std::make_unique<Rational>(std::move(in)); return *this;}
TokVal& TokVal::operator=(ScatteringMetaData in) {*tokval_type(ptr) = std::make_unique<ScatteringMetaData>(std::move(in)); return *this;}
TokVal& TokVal::operator=(SingleScatteringData in) {*tokval_type(ptr) = std::make_unique<SingleScatteringData>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Sparse in) {*tokval_type(ptr) = std::make_unique<Sparse>(std::move(in)); return *this;}
TokVal& TokVal::operator=(SpeciesIsotopologueRatios in) {*tokval_type(ptr) = std::make_unique<SpeciesIsotopologueRatios>(std::move(in)); return *this;}
TokVal& TokVal::operator=(SpectralRadianceProfileOperator in) {*tokval_type(ptr) = std::make_unique<SpectralRadianceProfileOperator>(std::move(in)); return *this;}
TokVal& TokVal::operator=(StokesVector in) {*tokval_type(ptr) = std::make_unique<StokesVector>(std::move(in)); return *this;}
TokVal& TokVal::operator=(String in) {*tokval_type(ptr) = std::make_unique<String>(std::move(in)); return *this;}
TokVal& TokVal::operator=(TelsemAtlas in) {*tokval_type(ptr) = std::make_unique<TelsemAtlas>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Tensor3 in) {*tokval_type(ptr) = std::make_unique<Tensor3>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Tensor4 in) {*tokval_type(ptr) = std::make_unique<Tensor4>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Tensor5 in) {*tokval_type(ptr) = std::make_unique<Tensor5>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Tensor6 in) {*tokval_type(ptr) = std::make_unique<Tensor6>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Tensor7 in) {*tokval_type(ptr) = std::make_unique<Tensor7>(std::move(in)); return *this;}
TokVal& TokVal::operator=(TessemNN in) {*tokval_type(ptr) = std::make_unique<TessemNN>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Time in) {*tokval_type(ptr) = std::make_unique<Time>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Timer in) {*tokval_type(ptr) = std::make_unique<Timer>(std::move(in)); return *this;}
TokVal& TokVal::operator=(TransmissionMatrix in) {*tokval_type(ptr) = std::make_unique<TransmissionMatrix>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Vector in) {*tokval_type(ptr) = std::make_unique<Vector>(std::move(in)); return *this;}
TokVal& TokVal::operator=(Verbosity in) {*tokval_type(ptr) = std::make_unique<Verbosity>(std::move(in)); return *this;}
 
bool TokVal::holdsAbsorptionLines() const {return std::holds_alternative<std::unique_ptr<AbsorptionLines>>(*tokval_type(ptr));}
bool TokVal::holdsAgenda() const {return std::holds_alternative<std::unique_ptr<Agenda>>(*tokval_type(ptr));}
bool TokVal::holdsAny() const {return std::holds_alternative<std::unique_ptr<Any>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfAbsorptionLines() const {return std::holds_alternative<std::unique_ptr<ArrayOfAbsorptionLines>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfAgenda() const {return std::holds_alternative<std::unique_ptr<ArrayOfAgenda>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfAbsorptionLines() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfAbsorptionLines>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfGriddedField1() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfGriddedField1>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfGriddedField2() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfGriddedField2>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfGriddedField3() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfGriddedField3>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfIndex() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfIndex>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfMatrix() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfMatrix>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfPropagationMatrix() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfPropagationMatrix>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfRadiationVector() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfRadiationVector>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfScatteringMetaData() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfScatteringMetaData>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfSingleScatteringData() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfSingleScatteringData>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfSpeciesTag() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfSpeciesTag>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfStokesVector() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfStokesVector>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfString() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfString>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfTensor3() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfTensor3>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfTensor6() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfTensor6>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfTime() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfTime>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfTransmissionMatrix() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfTransmissionMatrix>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfArrayOfVector() const {return std::holds_alternative<std::unique_ptr<ArrayOfArrayOfVector>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfCIARecord() const {return std::holds_alternative<std::unique_ptr<ArrayOfCIARecord>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfGriddedField1() const {return std::holds_alternative<std::unique_ptr<ArrayOfGriddedField1>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfGriddedField2() const {return std::holds_alternative<std::unique_ptr<ArrayOfGriddedField2>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfGriddedField3() const {return std::holds_alternative<std::unique_ptr<ArrayOfGriddedField3>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfGriddedField4() const {return std::holds_alternative<std::unique_ptr<ArrayOfGriddedField4>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfIndex() const {return std::holds_alternative<std::unique_ptr<ArrayOfIndex>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfJacobianTarget() const {return std::holds_alternative<std::unique_ptr<ArrayOfJacobianTarget>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfMatrix() const {return std::holds_alternative<std::unique_ptr<ArrayOfMatrix>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfPpath() const {return std::holds_alternative<std::unique_ptr<ArrayOfPpath>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfPropagationMatrix() const {return std::holds_alternative<std::unique_ptr<ArrayOfPropagationMatrix>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfQuantumIdentifier() const {return std::holds_alternative<std::unique_ptr<ArrayOfQuantumIdentifier>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfRadiationVector() const {return std::holds_alternative<std::unique_ptr<ArrayOfRadiationVector>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfRetrievalQuantity() const {return std::holds_alternative<std::unique_ptr<ArrayOfRetrievalQuantity>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfScatteringMetaData() const {return std::holds_alternative<std::unique_ptr<ArrayOfScatteringMetaData>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfSingleScatteringData() const {return std::holds_alternative<std::unique_ptr<ArrayOfSingleScatteringData>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfSparse() const {return std::holds_alternative<std::unique_ptr<ArrayOfSparse>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfSpeciesTag() const {return std::holds_alternative<std::unique_ptr<ArrayOfSpeciesTag>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfStokesVector() const {return std::holds_alternative<std::unique_ptr<ArrayOfStokesVector>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfString() const {return std::holds_alternative<std::unique_ptr<ArrayOfString>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfSun() const {return std::holds_alternative<std::unique_ptr<ArrayOfSun>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfTelsemAtlas() const {return std::holds_alternative<std::unique_ptr<ArrayOfTelsemAtlas>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfTensor3() const {return std::holds_alternative<std::unique_ptr<ArrayOfTensor3>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfTensor4() const {return std::holds_alternative<std::unique_ptr<ArrayOfTensor4>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfTensor5() const {return std::holds_alternative<std::unique_ptr<ArrayOfTensor5>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfTensor6() const {return std::holds_alternative<std::unique_ptr<ArrayOfTensor6>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfTensor7() const {return std::holds_alternative<std::unique_ptr<ArrayOfTensor7>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfTime() const {return std::holds_alternative<std::unique_ptr<ArrayOfTime>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfTransmissionMatrix() const {return std::holds_alternative<std::unique_ptr<ArrayOfTransmissionMatrix>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfVector() const {return std::holds_alternative<std::unique_ptr<ArrayOfVector>>(*tokval_type(ptr));}
bool TokVal::holdsArrayOfXsecRecord() const {return std::holds_alternative<std::unique_ptr<ArrayOfXsecRecord>>(*tokval_type(ptr));}
bool TokVal::holdsCIARecord() const {return std::holds_alternative<std::unique_ptr<CIARecord>>(*tokval_type(ptr));}
bool TokVal::holdsCallbackFunction() const {return std::holds_alternative<std::unique_ptr<CallbackFunction>>(*tokval_type(ptr));}
bool TokVal::holdsCovarianceMatrix() const {return std::holds_alternative<std::unique_ptr<CovarianceMatrix>>(*tokval_type(ptr));}
bool TokVal::holdsEnergyLevelMap() const {return std::holds_alternative<std::unique_ptr<EnergyLevelMap>>(*tokval_type(ptr));}
bool TokVal::holdsGasAbsLookup() const {return std::holds_alternative<std::unique_ptr<GasAbsLookup>>(*tokval_type(ptr));}
bool TokVal::holdsGridPos() const {return std::holds_alternative<std::unique_ptr<GridPos>>(*tokval_type(ptr));}
bool TokVal::holdsGriddedField1() const {return std::holds_alternative<std::unique_ptr<GriddedField1>>(*tokval_type(ptr));}
bool TokVal::holdsGriddedField2() const {return std::holds_alternative<std::unique_ptr<GriddedField2>>(*tokval_type(ptr));}
bool TokVal::holdsGriddedField3() const {return std::holds_alternative<std::unique_ptr<GriddedField3>>(*tokval_type(ptr));}
bool TokVal::holdsGriddedField4() const {return std::holds_alternative<std::unique_ptr<GriddedField4>>(*tokval_type(ptr));}
bool TokVal::holdsGriddedField5() const {return std::holds_alternative<std::unique_ptr<GriddedField5>>(*tokval_type(ptr));}
bool TokVal::holdsGriddedField6() const {return std::holds_alternative<std::unique_ptr<GriddedField6>>(*tokval_type(ptr));}
bool TokVal::holdsHitranRelaxationMatrixData() const {return std::holds_alternative<std::unique_ptr<HitranRelaxationMatrixData>>(*tokval_type(ptr));}
bool TokVal::holdsIndex() const {return std::holds_alternative<std::unique_ptr<Index>>(*tokval_type(ptr));}
bool TokVal::holdsJacobianTarget() const {return std::holds_alternative<std::unique_ptr<JacobianTarget>>(*tokval_type(ptr));}
bool TokVal::holdsMCAntenna() const {return std::holds_alternative<std::unique_ptr<MCAntenna>>(*tokval_type(ptr));}
bool TokVal::holdsMapOfErrorCorrectedSuddenData() const {return std::holds_alternative<std::unique_ptr<MapOfErrorCorrectedSuddenData>>(*tokval_type(ptr));}
bool TokVal::holdsMatrix() const {return std::holds_alternative<std::unique_ptr<Matrix>>(*tokval_type(ptr));}
bool TokVal::holdsNumeric() const {return std::holds_alternative<std::unique_ptr<Numeric>>(*tokval_type(ptr));}
bool TokVal::holdsPpath() const {return std::holds_alternative<std::unique_ptr<Ppath>>(*tokval_type(ptr));}
bool TokVal::holdsPredefinedModelData() const {return std::holds_alternative<std::unique_ptr<PredefinedModelData>>(*tokval_type(ptr));}
bool TokVal::holdsPropagationMatrix() const {return std::holds_alternative<std::unique_ptr<PropagationMatrix>>(*tokval_type(ptr));}
bool TokVal::holdsQuantumIdentifier() const {return std::holds_alternative<std::unique_ptr<QuantumIdentifier>>(*tokval_type(ptr));}
bool TokVal::holdsRadiationVector() const {return std::holds_alternative<std::unique_ptr<RadiationVector>>(*tokval_type(ptr));}
bool TokVal::holdsRational() const {return std::holds_alternative<std::unique_ptr<Rational>>(*tokval_type(ptr));}
bool TokVal::holdsScatteringMetaData() const {return std::holds_alternative<std::unique_ptr<ScatteringMetaData>>(*tokval_type(ptr));}
bool TokVal::holdsSingleScatteringData() const {return std::holds_alternative<std::unique_ptr<SingleScatteringData>>(*tokval_type(ptr));}
bool TokVal::holdsSparse() const {return std::holds_alternative<std::unique_ptr<Sparse>>(*tokval_type(ptr));}
bool TokVal::holdsSpeciesIsotopologueRatios() const {return std::holds_alternative<std::unique_ptr<SpeciesIsotopologueRatios>>(*tokval_type(ptr));}
bool TokVal::holdsSpectralRadianceProfileOperator() const {return std::holds_alternative<std::unique_ptr<SpectralRadianceProfileOperator>>(*tokval_type(ptr));}
bool TokVal::holdsStokesVector() const {return std::holds_alternative<std::unique_ptr<StokesVector>>(*tokval_type(ptr));}
bool TokVal::holdsString() const {return std::holds_alternative<std::unique_ptr<String>>(*tokval_type(ptr));}
bool TokVal::holdsTelsemAtlas() const {return std::holds_alternative<std::unique_ptr<TelsemAtlas>>(*tokval_type(ptr));}
bool TokVal::holdsTensor3() const {return std::holds_alternative<std::unique_ptr<Tensor3>>(*tokval_type(ptr));}
bool TokVal::holdsTensor4() const {return std::holds_alternative<std::unique_ptr<Tensor4>>(*tokval_type(ptr));}
bool TokVal::holdsTensor5() const {return std::holds_alternative<std::unique_ptr<Tensor5>>(*tokval_type(ptr));}
bool TokVal::holdsTensor6() const {return std::holds_alternative<std::unique_ptr<Tensor6>>(*tokval_type(ptr));}
bool TokVal::holdsTensor7() const {return std::holds_alternative<std::unique_ptr<Tensor7>>(*tokval_type(ptr));}
bool TokVal::holdsTessemNN() const {return std::holds_alternative<std::unique_ptr<TessemNN>>(*tokval_type(ptr));}
bool TokVal::holdsTime() const {return std::holds_alternative<std::unique_ptr<Time>>(*tokval_type(ptr));}
bool TokVal::holdsTimer() const {return std::holds_alternative<std::unique_ptr<Timer>>(*tokval_type(ptr));}
bool TokVal::holdsTransmissionMatrix() const {return std::holds_alternative<std::unique_ptr<TransmissionMatrix>>(*tokval_type(ptr));}
bool TokVal::holdsVector() const {return std::holds_alternative<std::unique_ptr<Vector>>(*tokval_type(ptr));}
bool TokVal::holdsVerbosity() const {return std::holds_alternative<std::unique_ptr<Verbosity>>(*tokval_type(ptr));}
 
TokVal::operator AbsorptionLines() const {
   ARTS_USER_ERROR_IF(not holdsAbsorptionLines(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<AbsorptionLines>>(tokval_type(ptr));
}
TokVal::operator Agenda() const {
   ARTS_USER_ERROR_IF(not holdsAgenda(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Agenda>>(tokval_type(ptr));
}
TokVal::operator Any() const {
   ARTS_USER_ERROR_IF(not holdsAny(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Any>>(tokval_type(ptr));
}
TokVal::operator ArrayOfAbsorptionLines() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfAbsorptionLines(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfAbsorptionLines>>(tokval_type(ptr));
}
TokVal::operator ArrayOfAgenda() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfAgenda(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfAgenda>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfAbsorptionLines() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfAbsorptionLines(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfAbsorptionLines>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfGriddedField1() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfGriddedField1(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfGriddedField1>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfGriddedField2() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfGriddedField2(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfGriddedField2>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfGriddedField3() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfGriddedField3(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfGriddedField3>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfIndex() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfIndex(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfIndex>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfMatrix() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfMatrix(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfMatrix>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfPropagationMatrix() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfPropagationMatrix(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfPropagationMatrix>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfRadiationVector() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfRadiationVector(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfRadiationVector>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfScatteringMetaData() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfScatteringMetaData(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfScatteringMetaData>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfSingleScatteringData() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfSingleScatteringData(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfSingleScatteringData>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfSpeciesTag() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfSpeciesTag(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfSpeciesTag>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfStokesVector() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfStokesVector(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfStokesVector>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfString() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfString(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfString>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfTensor3() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfTensor3(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfTensor3>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfTensor6() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfTensor6(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfTensor6>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfTime() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfTime(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfTime>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfTransmissionMatrix() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfTransmissionMatrix(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfTransmissionMatrix>>(tokval_type(ptr));
}
TokVal::operator ArrayOfArrayOfVector() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfArrayOfVector(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfArrayOfVector>>(tokval_type(ptr));
}
TokVal::operator ArrayOfCIARecord() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfCIARecord(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfCIARecord>>(tokval_type(ptr));
}
TokVal::operator ArrayOfGriddedField1() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfGriddedField1(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfGriddedField1>>(tokval_type(ptr));
}
TokVal::operator ArrayOfGriddedField2() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfGriddedField2(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfGriddedField2>>(tokval_type(ptr));
}
TokVal::operator ArrayOfGriddedField3() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfGriddedField3(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfGriddedField3>>(tokval_type(ptr));
}
TokVal::operator ArrayOfGriddedField4() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfGriddedField4(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfGriddedField4>>(tokval_type(ptr));
}
TokVal::operator ArrayOfIndex() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfIndex(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfIndex>>(tokval_type(ptr));
}
TokVal::operator ArrayOfJacobianTarget() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfJacobianTarget(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfJacobianTarget>>(tokval_type(ptr));
}
TokVal::operator ArrayOfMatrix() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfMatrix(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfMatrix>>(tokval_type(ptr));
}
TokVal::operator ArrayOfPpath() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfPpath(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfPpath>>(tokval_type(ptr));
}
TokVal::operator ArrayOfPropagationMatrix() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfPropagationMatrix(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfPropagationMatrix>>(tokval_type(ptr));
}
TokVal::operator ArrayOfQuantumIdentifier() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfQuantumIdentifier(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfQuantumIdentifier>>(tokval_type(ptr));
}
TokVal::operator ArrayOfRadiationVector() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfRadiationVector(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfRadiationVector>>(tokval_type(ptr));
}
TokVal::operator ArrayOfRetrievalQuantity() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfRetrievalQuantity(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfRetrievalQuantity>>(tokval_type(ptr));
}
TokVal::operator ArrayOfScatteringMetaData() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfScatteringMetaData(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfScatteringMetaData>>(tokval_type(ptr));
}
TokVal::operator ArrayOfSingleScatteringData() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfSingleScatteringData(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfSingleScatteringData>>(tokval_type(ptr));
}
TokVal::operator ArrayOfSparse() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfSparse(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfSparse>>(tokval_type(ptr));
}
TokVal::operator ArrayOfSpeciesTag() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfSpeciesTag(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfSpeciesTag>>(tokval_type(ptr));
}
TokVal::operator ArrayOfStokesVector() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfStokesVector(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfStokesVector>>(tokval_type(ptr));
}
TokVal::operator ArrayOfString() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfString(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfString>>(tokval_type(ptr));
}
TokVal::operator ArrayOfSun() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfSun(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfSun>>(tokval_type(ptr));
}
TokVal::operator ArrayOfTelsemAtlas() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfTelsemAtlas(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfTelsemAtlas>>(tokval_type(ptr));
}
TokVal::operator ArrayOfTensor3() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfTensor3(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfTensor3>>(tokval_type(ptr));
}
TokVal::operator ArrayOfTensor4() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfTensor4(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfTensor4>>(tokval_type(ptr));
}
TokVal::operator ArrayOfTensor5() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfTensor5(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfTensor5>>(tokval_type(ptr));
}
TokVal::operator ArrayOfTensor6() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfTensor6(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfTensor6>>(tokval_type(ptr));
}
TokVal::operator ArrayOfTensor7() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfTensor7(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfTensor7>>(tokval_type(ptr));
}
TokVal::operator ArrayOfTime() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfTime(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfTime>>(tokval_type(ptr));
}
TokVal::operator ArrayOfTransmissionMatrix() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfTransmissionMatrix(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfTransmissionMatrix>>(tokval_type(ptr));
}
TokVal::operator ArrayOfVector() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfVector(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfVector>>(tokval_type(ptr));
}
TokVal::operator ArrayOfXsecRecord() const {
   ARTS_USER_ERROR_IF(not holdsArrayOfXsecRecord(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ArrayOfXsecRecord>>(tokval_type(ptr));
}
TokVal::operator CIARecord() const {
   ARTS_USER_ERROR_IF(not holdsCIARecord(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<CIARecord>>(tokval_type(ptr));
}
TokVal::operator CallbackFunction() const {
   ARTS_USER_ERROR_IF(not holdsCallbackFunction(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<CallbackFunction>>(tokval_type(ptr));
}
TokVal::operator CovarianceMatrix() const {
   ARTS_USER_ERROR_IF(not holdsCovarianceMatrix(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<CovarianceMatrix>>(tokval_type(ptr));
}
TokVal::operator EnergyLevelMap() const {
   ARTS_USER_ERROR_IF(not holdsEnergyLevelMap(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<EnergyLevelMap>>(tokval_type(ptr));
}
TokVal::operator GasAbsLookup() const {
   ARTS_USER_ERROR_IF(not holdsGasAbsLookup(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<GasAbsLookup>>(tokval_type(ptr));
}
TokVal::operator GridPos() const {
   ARTS_USER_ERROR_IF(not holdsGridPos(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<GridPos>>(tokval_type(ptr));
}
TokVal::operator GriddedField1() const {
   ARTS_USER_ERROR_IF(not holdsGriddedField1(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<GriddedField1>>(tokval_type(ptr));
}
TokVal::operator GriddedField2() const {
   ARTS_USER_ERROR_IF(not holdsGriddedField2(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<GriddedField2>>(tokval_type(ptr));
}
TokVal::operator GriddedField3() const {
   ARTS_USER_ERROR_IF(not holdsGriddedField3(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<GriddedField3>>(tokval_type(ptr));
}
TokVal::operator GriddedField4() const {
   ARTS_USER_ERROR_IF(not holdsGriddedField4(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<GriddedField4>>(tokval_type(ptr));
}
TokVal::operator GriddedField5() const {
   ARTS_USER_ERROR_IF(not holdsGriddedField5(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<GriddedField5>>(tokval_type(ptr));
}
TokVal::operator GriddedField6() const {
   ARTS_USER_ERROR_IF(not holdsGriddedField6(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<GriddedField6>>(tokval_type(ptr));
}
TokVal::operator HitranRelaxationMatrixData() const {
   ARTS_USER_ERROR_IF(not holdsHitranRelaxationMatrixData(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<HitranRelaxationMatrixData>>(tokval_type(ptr));
}
TokVal::operator Index() const {
   ARTS_USER_ERROR_IF(not holdsIndex(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Index>>(tokval_type(ptr));
}
TokVal::operator JacobianTarget() const {
   ARTS_USER_ERROR_IF(not holdsJacobianTarget(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<JacobianTarget>>(tokval_type(ptr));
}
TokVal::operator MCAntenna() const {
   ARTS_USER_ERROR_IF(not holdsMCAntenna(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<MCAntenna>>(tokval_type(ptr));
}
TokVal::operator MapOfErrorCorrectedSuddenData() const {
   ARTS_USER_ERROR_IF(not holdsMapOfErrorCorrectedSuddenData(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<MapOfErrorCorrectedSuddenData>>(tokval_type(ptr));
}
TokVal::operator Matrix() const {
   ARTS_USER_ERROR_IF(not holdsMatrix(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Matrix>>(tokval_type(ptr));
}
TokVal::operator Numeric() const {
   ARTS_USER_ERROR_IF(not holdsNumeric(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Numeric>>(tokval_type(ptr));
}
TokVal::operator Ppath() const {
   ARTS_USER_ERROR_IF(not holdsPpath(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Ppath>>(tokval_type(ptr));
}
TokVal::operator PredefinedModelData() const {
   ARTS_USER_ERROR_IF(not holdsPredefinedModelData(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<PredefinedModelData>>(tokval_type(ptr));
}
TokVal::operator PropagationMatrix() const {
   ARTS_USER_ERROR_IF(not holdsPropagationMatrix(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<PropagationMatrix>>(tokval_type(ptr));
}
TokVal::operator QuantumIdentifier() const {
   ARTS_USER_ERROR_IF(not holdsQuantumIdentifier(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<QuantumIdentifier>>(tokval_type(ptr));
}
TokVal::operator RadiationVector() const {
   ARTS_USER_ERROR_IF(not holdsRadiationVector(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<RadiationVector>>(tokval_type(ptr));
}
TokVal::operator Rational() const {
   ARTS_USER_ERROR_IF(not holdsRational(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Rational>>(tokval_type(ptr));
}
TokVal::operator ScatteringMetaData() const {
   ARTS_USER_ERROR_IF(not holdsScatteringMetaData(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<ScatteringMetaData>>(tokval_type(ptr));
}
TokVal::operator SingleScatteringData() const {
   ARTS_USER_ERROR_IF(not holdsSingleScatteringData(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<SingleScatteringData>>(tokval_type(ptr));
}
TokVal::operator Sparse() const {
   ARTS_USER_ERROR_IF(not holdsSparse(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Sparse>>(tokval_type(ptr));
}
TokVal::operator SpeciesIsotopologueRatios() const {
   ARTS_USER_ERROR_IF(not holdsSpeciesIsotopologueRatios(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<SpeciesIsotopologueRatios>>(tokval_type(ptr));
}
TokVal::operator SpectralRadianceProfileOperator() const {
   ARTS_USER_ERROR_IF(not holdsSpectralRadianceProfileOperator(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<SpectralRadianceProfileOperator>>(tokval_type(ptr));
}
TokVal::operator StokesVector() const {
   ARTS_USER_ERROR_IF(not holdsStokesVector(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<StokesVector>>(tokval_type(ptr));
}
TokVal::operator String() const {
   ARTS_USER_ERROR_IF(not holdsString(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<String>>(tokval_type(ptr));
}
TokVal::operator TelsemAtlas() const {
   ARTS_USER_ERROR_IF(not holdsTelsemAtlas(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<TelsemAtlas>>(tokval_type(ptr));
}
TokVal::operator Tensor3() const {
   ARTS_USER_ERROR_IF(not holdsTensor3(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Tensor3>>(tokval_type(ptr));
}
TokVal::operator Tensor4() const {
   ARTS_USER_ERROR_IF(not holdsTensor4(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Tensor4>>(tokval_type(ptr));
}
TokVal::operator Tensor5() const {
   ARTS_USER_ERROR_IF(not holdsTensor5(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Tensor5>>(tokval_type(ptr));
}
TokVal::operator Tensor6() const {
   ARTS_USER_ERROR_IF(not holdsTensor6(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Tensor6>>(tokval_type(ptr));
}
TokVal::operator Tensor7() const {
   ARTS_USER_ERROR_IF(not holdsTensor7(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Tensor7>>(tokval_type(ptr));
}
TokVal::operator TessemNN() const {
   ARTS_USER_ERROR_IF(not holdsTessemNN(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<TessemNN>>(tokval_type(ptr));
}
TokVal::operator Time() const {
   ARTS_USER_ERROR_IF(not holdsTime(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Time>>(tokval_type(ptr));
}
TokVal::operator Timer() const {
   ARTS_USER_ERROR_IF(not holdsTimer(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Timer>>(tokval_type(ptr));
}
TokVal::operator TransmissionMatrix() const {
   ARTS_USER_ERROR_IF(not holdsTransmissionMatrix(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<TransmissionMatrix>>(tokval_type(ptr));
}
TokVal::operator Vector() const {
   ARTS_USER_ERROR_IF(not holdsVector(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Vector>>(tokval_type(ptr));
}
TokVal::operator Verbosity() const {
   ARTS_USER_ERROR_IF(not holdsVerbosity(), "Wrong type: ", type())
  return **std::get_if<std::unique_ptr<Verbosity>>(tokval_type(ptr));
}
[[nodiscard]] std::string_view TokVal::type() const {
  if (holdsAbsorptionLines()) return "AbsorptionLines";
  if (holdsAgenda()) return "Agenda";
  if (holdsAny()) return "Any";
  if (holdsArrayOfAbsorptionLines()) return "ArrayOfAbsorptionLines";
  if (holdsArrayOfAgenda()) return "ArrayOfAgenda";
  if (holdsArrayOfArrayOfAbsorptionLines()) return "ArrayOfArrayOfAbsorptionLines";
  if (holdsArrayOfArrayOfGriddedField1()) return "ArrayOfArrayOfGriddedField1";
  if (holdsArrayOfArrayOfGriddedField2()) return "ArrayOfArrayOfGriddedField2";
  if (holdsArrayOfArrayOfGriddedField3()) return "ArrayOfArrayOfGriddedField3";
  if (holdsArrayOfArrayOfIndex()) return "ArrayOfArrayOfIndex";
  if (holdsArrayOfArrayOfMatrix()) return "ArrayOfArrayOfMatrix";
  if (holdsArrayOfArrayOfPropagationMatrix()) return "ArrayOfArrayOfPropagationMatrix";
  if (holdsArrayOfArrayOfRadiationVector()) return "ArrayOfArrayOfRadiationVector";
  if (holdsArrayOfArrayOfScatteringMetaData()) return "ArrayOfArrayOfScatteringMetaData";
  if (holdsArrayOfArrayOfSingleScatteringData()) return "ArrayOfArrayOfSingleScatteringData";
  if (holdsArrayOfArrayOfSpeciesTag()) return "ArrayOfArrayOfSpeciesTag";
  if (holdsArrayOfArrayOfStokesVector()) return "ArrayOfArrayOfStokesVector";
  if (holdsArrayOfArrayOfString()) return "ArrayOfArrayOfString";
  if (holdsArrayOfArrayOfTensor3()) return "ArrayOfArrayOfTensor3";
  if (holdsArrayOfArrayOfTensor6()) return "ArrayOfArrayOfTensor6";
  if (holdsArrayOfArrayOfTime()) return "ArrayOfArrayOfTime";
  if (holdsArrayOfArrayOfTransmissionMatrix()) return "ArrayOfArrayOfTransmissionMatrix";
  if (holdsArrayOfArrayOfVector()) return "ArrayOfArrayOfVector";
  if (holdsArrayOfCIARecord()) return "ArrayOfCIARecord";
  if (holdsArrayOfGriddedField1()) return "ArrayOfGriddedField1";
  if (holdsArrayOfGriddedField2()) return "ArrayOfGriddedField2";
  if (holdsArrayOfGriddedField3()) return "ArrayOfGriddedField3";
  if (holdsArrayOfGriddedField4()) return "ArrayOfGriddedField4";
  if (holdsArrayOfIndex()) return "ArrayOfIndex";
  if (holdsArrayOfJacobianTarget()) return "ArrayOfJacobianTarget";
  if (holdsArrayOfMatrix()) return "ArrayOfMatrix";
  if (holdsArrayOfPpath()) return "ArrayOfPpath";
  if (holdsArrayOfPropagationMatrix()) return "ArrayOfPropagationMatrix";
  if (holdsArrayOfQuantumIdentifier()) return "ArrayOfQuantumIdentifier";
  if (holdsArrayOfRadiationVector()) return "ArrayOfRadiationVector";
  if (holdsArrayOfRetrievalQuantity()) return "ArrayOfRetrievalQuantity";
  if (holdsArrayOfScatteringMetaData()) return "ArrayOfScatteringMetaData";
  if (holdsArrayOfSingleScatteringData()) return "ArrayOfSingleScatteringData";
  if (holdsArrayOfSparse()) return "ArrayOfSparse";
  if (holdsArrayOfSpeciesTag()) return "ArrayOfSpeciesTag";
  if (holdsArrayOfStokesVector()) return "ArrayOfStokesVector";
  if (holdsArrayOfString()) return "ArrayOfString";
  if (holdsArrayOfSun()) return "ArrayOfSun";
  if (holdsArrayOfTelsemAtlas()) return "ArrayOfTelsemAtlas";
  if (holdsArrayOfTensor3()) return "ArrayOfTensor3";
  if (holdsArrayOfTensor4()) return "ArrayOfTensor4";
  if (holdsArrayOfTensor5()) return "ArrayOfTensor5";
  if (holdsArrayOfTensor6()) return "ArrayOfTensor6";
  if (holdsArrayOfTensor7()) return "ArrayOfTensor7";
  if (holdsArrayOfTime()) return "ArrayOfTime";
  if (holdsArrayOfTransmissionMatrix()) return "ArrayOfTransmissionMatrix";
  if (holdsArrayOfVector()) return "ArrayOfVector";
  if (holdsArrayOfXsecRecord()) return "ArrayOfXsecRecord";
  if (holdsCIARecord()) return "CIARecord";
  if (holdsCallbackFunction()) return "CallbackFunction";
  if (holdsCovarianceMatrix()) return "CovarianceMatrix";
  if (holdsEnergyLevelMap()) return "EnergyLevelMap";
  if (holdsGasAbsLookup()) return "GasAbsLookup";
  if (holdsGridPos()) return "GridPos";
  if (holdsGriddedField1()) return "GriddedField1";
  if (holdsGriddedField2()) return "GriddedField2";
  if (holdsGriddedField3()) return "GriddedField3";
  if (holdsGriddedField4()) return "GriddedField4";
  if (holdsGriddedField5()) return "GriddedField5";
  if (holdsGriddedField6()) return "GriddedField6";
  if (holdsHitranRelaxationMatrixData()) return "HitranRelaxationMatrixData";
  if (holdsIndex()) return "Index";
  if (holdsJacobianTarget()) return "JacobianTarget";
  if (holdsMCAntenna()) return "MCAntenna";
  if (holdsMapOfErrorCorrectedSuddenData()) return "MapOfErrorCorrectedSuddenData";
  if (holdsMatrix()) return "Matrix";
  if (holdsNumeric()) return "Numeric";
  if (holdsPpath()) return "Ppath";
  if (holdsPredefinedModelData()) return "PredefinedModelData";
  if (holdsPropagationMatrix()) return "PropagationMatrix";
  if (holdsQuantumIdentifier()) return "QuantumIdentifier";
  if (holdsRadiationVector()) return "RadiationVector";
  if (holdsRational()) return "Rational";
  if (holdsScatteringMetaData()) return "ScatteringMetaData";
  if (holdsSingleScatteringData()) return "SingleScatteringData";
  if (holdsSparse()) return "Sparse";
  if (holdsSpeciesIsotopologueRatios()) return "SpeciesIsotopologueRatios";
  if (holdsSpectralRadianceProfileOperator()) return "SpectralRadianceProfileOperator";
  if (holdsStokesVector()) return "StokesVector";
  if (holdsString()) return "String";
  if (holdsTelsemAtlas()) return "TelsemAtlas";
  if (holdsTensor3()) return "Tensor3";
  if (holdsTensor4()) return "Tensor4";
  if (holdsTensor5()) return "Tensor5";
  if (holdsTensor6()) return "Tensor6";
  if (holdsTensor7()) return "Tensor7";
  if (holdsTessemNN()) return "TessemNN";
  if (holdsTime()) return "Time";
  if (holdsTimer()) return "Timer";
  if (holdsTransmissionMatrix()) return "TransmissionMatrix";
  if (holdsVector()) return "Vector";
  if (holdsVerbosity()) return "Verbosity";
return "this is a nonsense results!";
}
   
TokVal::TokVal(const char * const c) : TokVal(String(c)) {}
    
TokVal::TokVal() : TokVal(Any{}) {}
TokVal::TokVal(const TokVal& v) : TokVal(Any{}) { *this = v; }
TokVal& TokVal::operator=(const TokVal& v) {
  delete tokval_type(ptr);
  ptr = std::visit([&](auto&& in) -> void* {
    return new TokValType{std::make_unique<std::remove_cvref_t<decltype(*in)>>(*in)};
  }, *tokval_type(v.ptr));
  return *this;
}
 
TokVal::~TokVal() noexcept {delete tokval_type(ptr); ptr=nullptr;}
 
std::shared_ptr<void> TokVal::copy_value() const {
  return std::visit(
    [](auto&& val) -> std::shared_ptr<void> {
      using value_type =
          std::remove_cv_t<std::remove_pointer_t<decltype(val.get())>>;
      return std::make_shared<value_type>(*val);
    },
    *tokval_type(ptr));
}