Line data    Source code

       1             : 
       2             : /*
       3             :  * ALMA - Atacama Large Millimeter Array
       4             :  * (c) European Southern Observatory, 2002
       5             :  * (c) Associated Universities Inc., 2002
       6             :  * Copyright by ESO (in the framework of the ALMA collaboration),
       7             :  * Copyright by AUI (in the framework of the ALMA collaboration),
       8             :  * All rights reserved.
       9             :  * 
      10             :  * This library is free software; you can redistribute it and/or
      11             :  * modify it under the terms of the GNU Lesser General Public
      12             :  * License as published by the Free software Foundation; either
      13             :  * version 2.1 of the License, or (at your option) any later version.
      14             :  * 
      15             :  * This library is distributed in the hope that it will be useful,
      16             :  * but WITHOUT ANY WARRANTY, without even the implied warranty of
      17             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      18             :  * Lesser General Public License for more details.
      19             :  * 
      20             :  * You should have received a copy of the GNU Lesser General Public
      21             :  * License along with this library; if not, write to the Free Software
      22             :  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
      23             :  * MA 02111-1307  USA
      24             :  * 
      25             :  * /////////////////////////////////////////////////////////////////
      26             :  * // WARNING!  DO NOT MODIFY THIS FILE!                          //
      27             :  * //  ---------------------------------------------------------  //
      28             :  * // | This is generated code!  Do not modify this file.       | //
      29             :  * // | Any changes will be lost when the file is re-generated. | //
      30             :  * //  ---------------------------------------------------------  //
      31             :  * /////////////////////////////////////////////////////////////////
      32             :  *
      33             :  * File CScanIntent.cpp
      34             :  */
      35             : #include <sstream>
      36             : #include <alma/Enumerations/CScanIntent.h>
      37             : #include <string>
      38             : using namespace std;
      39             : 
      40           0 : int CScanIntent::version() {
      41           0 :         return ScanIntentMod::version;
      42             :         }
      43             :         
      44           0 : string CScanIntent::revision () {
      45           0 :         return ScanIntentMod::revision;
      46             : }
      47             : 
      48           0 : unsigned int CScanIntent::size() {
      49           0 :         return 30;
      50             :         }
      51             :         
      52             :         
      53             : const std::string& CScanIntent::sCALIBRATE_AMPLI = "CALIBRATE_AMPLI";
      54             :         
      55             : const std::string& CScanIntent::sCALIBRATE_ATMOSPHERE = "CALIBRATE_ATMOSPHERE";
      56             :         
      57             : const std::string& CScanIntent::sCALIBRATE_BANDPASS = "CALIBRATE_BANDPASS";
      58             :         
      59             : const std::string& CScanIntent::sCALIBRATE_DELAY = "CALIBRATE_DELAY";
      60             :         
      61             : const std::string& CScanIntent::sCALIBRATE_FLUX = "CALIBRATE_FLUX";
      62             :         
      63             : const std::string& CScanIntent::sCALIBRATE_FOCUS = "CALIBRATE_FOCUS";
      64             :         
      65             : const std::string& CScanIntent::sCALIBRATE_FOCUS_X = "CALIBRATE_FOCUS_X";
      66             :         
      67             : const std::string& CScanIntent::sCALIBRATE_FOCUS_Y = "CALIBRATE_FOCUS_Y";
      68             :         
      69             : const std::string& CScanIntent::sCALIBRATE_PHASE = "CALIBRATE_PHASE";
      70             :         
      71             : const std::string& CScanIntent::sCALIBRATE_POINTING = "CALIBRATE_POINTING";
      72             :         
      73             : const std::string& CScanIntent::sCALIBRATE_POLARIZATION = "CALIBRATE_POLARIZATION";
      74             :         
      75             : const std::string& CScanIntent::sCALIBRATE_SIDEBAND_RATIO = "CALIBRATE_SIDEBAND_RATIO";
      76             :         
      77             : const std::string& CScanIntent::sCALIBRATE_WVR = "CALIBRATE_WVR";
      78             :         
      79             : const std::string& CScanIntent::sDO_SKYDIP = "DO_SKYDIP";
      80             :         
      81             : const std::string& CScanIntent::sMAP_ANTENNA_SURFACE = "MAP_ANTENNA_SURFACE";
      82             :         
      83             : const std::string& CScanIntent::sMAP_PRIMARY_BEAM = "MAP_PRIMARY_BEAM";
      84             :         
      85             : const std::string& CScanIntent::sOBSERVE_TARGET = "OBSERVE_TARGET";
      86             :         
      87             : const std::string& CScanIntent::sCALIBRATE_POL_LEAKAGE = "CALIBRATE_POL_LEAKAGE";
      88             :         
      89             : const std::string& CScanIntent::sCALIBRATE_POL_ANGLE = "CALIBRATE_POL_ANGLE";
      90             :         
      91             : const std::string& CScanIntent::sTEST = "TEST";
      92             :         
      93             : const std::string& CScanIntent::sUNSPECIFIED = "UNSPECIFIED";
      94             :         
      95             : const std::string& CScanIntent::sCALIBRATE_ANTENNA_POSITION = "CALIBRATE_ANTENNA_POSITION";
      96             :         
      97             : const std::string& CScanIntent::sCALIBRATE_ANTENNA_PHASE = "CALIBRATE_ANTENNA_PHASE";
      98             :         
      99             : const std::string& CScanIntent::sMEASURE_RFI = "MEASURE_RFI";
     100             :         
     101             : const std::string& CScanIntent::sCALIBRATE_ANTENNA_POINTING_MODEL = "CALIBRATE_ANTENNA_POINTING_MODEL";
     102             :         
     103             : const std::string& CScanIntent::sSYSTEM_CONFIGURATION = "SYSTEM_CONFIGURATION";
     104             :         
     105             : const std::string& CScanIntent::sCALIBRATE_APPPHASE_ACTIVE = "CALIBRATE_APPPHASE_ACTIVE";
     106             :         
     107             : const std::string& CScanIntent::sCALIBRATE_APPPHASE_PASSIVE = "CALIBRATE_APPPHASE_PASSIVE";
     108             :         
     109             : const std::string& CScanIntent::sOBSERVE_CHECK_SOURCE = "OBSERVE_CHECK_SOURCE";
     110             :         
     111             : const std::string& CScanIntent::sCALIBRATE_DIFFGAIN = "CALIBRATE_DIFFGAIN";
     112             :         
     113           0 : const std::vector<std::string> CScanIntent::names() {
     114           0 :     std::vector<std::string> enumSet;
     115             :     
     116           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_AMPLI);
     117             :     
     118           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_ATMOSPHERE);
     119             :     
     120           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_BANDPASS);
     121             :     
     122           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_DELAY);
     123             :     
     124           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_FLUX);
     125             :     
     126           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_FOCUS);
     127             :     
     128           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_FOCUS_X);
     129             :     
     130           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_FOCUS_Y);
     131             :     
     132           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_PHASE);
     133             :     
     134           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_POINTING);
     135             :     
     136           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_POLARIZATION);
     137             :     
     138           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_SIDEBAND_RATIO);
     139             :     
     140           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_WVR);
     141             :     
     142           0 :     enumSet.insert(enumSet.end(), CScanIntent::sDO_SKYDIP);
     143             :     
     144           0 :     enumSet.insert(enumSet.end(), CScanIntent::sMAP_ANTENNA_SURFACE);
     145             :     
     146           0 :     enumSet.insert(enumSet.end(), CScanIntent::sMAP_PRIMARY_BEAM);
     147             :     
     148           0 :     enumSet.insert(enumSet.end(), CScanIntent::sOBSERVE_TARGET);
     149             :     
     150           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_POL_LEAKAGE);
     151             :     
     152           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_POL_ANGLE);
     153             :     
     154           0 :     enumSet.insert(enumSet.end(), CScanIntent::sTEST);
     155             :     
     156           0 :     enumSet.insert(enumSet.end(), CScanIntent::sUNSPECIFIED);
     157             :     
     158           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_ANTENNA_POSITION);
     159             :     
     160           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_ANTENNA_PHASE);
     161             :     
     162           0 :     enumSet.insert(enumSet.end(), CScanIntent::sMEASURE_RFI);
     163             :     
     164           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_ANTENNA_POINTING_MODEL);
     165             :     
     166           0 :     enumSet.insert(enumSet.end(), CScanIntent::sSYSTEM_CONFIGURATION);
     167             :     
     168           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_APPPHASE_ACTIVE);
     169             :     
     170           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_APPPHASE_PASSIVE);
     171             :     
     172           0 :     enumSet.insert(enumSet.end(), CScanIntent::sOBSERVE_CHECK_SOURCE);
     173             :     
     174           0 :     enumSet.insert(enumSet.end(), CScanIntent::sCALIBRATE_DIFFGAIN);
     175             :         
     176           0 :     return enumSet;
     177           0 : }
     178             : 
     179        3926 : std::string CScanIntent::name(const ScanIntentMod::ScanIntent& f) {
     180        3926 :     switch (f) {
     181             :     
     182          24 :     case ScanIntentMod::CALIBRATE_AMPLI:
     183          24 :       return CScanIntent::sCALIBRATE_AMPLI;
     184             :     
     185         281 :     case ScanIntentMod::CALIBRATE_ATMOSPHERE:
     186         281 :       return CScanIntent::sCALIBRATE_ATMOSPHERE;
     187             :     
     188           2 :     case ScanIntentMod::CALIBRATE_BANDPASS:
     189           2 :       return CScanIntent::sCALIBRATE_BANDPASS;
     190             :     
     191          72 :     case ScanIntentMod::CALIBRATE_DELAY:
     192          72 :       return CScanIntent::sCALIBRATE_DELAY;
     193             :     
     194           2 :     case ScanIntentMod::CALIBRATE_FLUX:
     195           2 :       return CScanIntent::sCALIBRATE_FLUX;
     196             :     
     197           0 :     case ScanIntentMod::CALIBRATE_FOCUS:
     198           0 :       return CScanIntent::sCALIBRATE_FOCUS;
     199             :     
     200           0 :     case ScanIntentMod::CALIBRATE_FOCUS_X:
     201           0 :       return CScanIntent::sCALIBRATE_FOCUS_X;
     202             :     
     203           0 :     case ScanIntentMod::CALIBRATE_FOCUS_Y:
     204           0 :       return CScanIntent::sCALIBRATE_FOCUS_Y;
     205             :     
     206          89 :     case ScanIntentMod::CALIBRATE_PHASE:
     207          89 :       return CScanIntent::sCALIBRATE_PHASE;
     208             :     
     209         305 :     case ScanIntentMod::CALIBRATE_POINTING:
     210         305 :       return CScanIntent::sCALIBRATE_POINTING;
     211             :     
     212           0 :     case ScanIntentMod::CALIBRATE_POLARIZATION:
     213           0 :       return CScanIntent::sCALIBRATE_POLARIZATION;
     214             :     
     215         124 :     case ScanIntentMod::CALIBRATE_SIDEBAND_RATIO:
     216         124 :       return CScanIntent::sCALIBRATE_SIDEBAND_RATIO;
     217             :     
     218        1624 :     case ScanIntentMod::CALIBRATE_WVR:
     219        1624 :       return CScanIntent::sCALIBRATE_WVR;
     220             :     
     221           0 :     case ScanIntentMod::DO_SKYDIP:
     222           0 :       return CScanIntent::sDO_SKYDIP;
     223             :     
     224           0 :     case ScanIntentMod::MAP_ANTENNA_SURFACE:
     225           0 :       return CScanIntent::sMAP_ANTENNA_SURFACE;
     226             :     
     227           0 :     case ScanIntentMod::MAP_PRIMARY_BEAM:
     228           0 :       return CScanIntent::sMAP_PRIMARY_BEAM;
     229             :     
     230        1403 :     case ScanIntentMod::OBSERVE_TARGET:
     231        1403 :       return CScanIntent::sOBSERVE_TARGET;
     232             :     
     233           0 :     case ScanIntentMod::CALIBRATE_POL_LEAKAGE:
     234           0 :       return CScanIntent::sCALIBRATE_POL_LEAKAGE;
     235             :     
     236           0 :     case ScanIntentMod::CALIBRATE_POL_ANGLE:
     237           0 :       return CScanIntent::sCALIBRATE_POL_ANGLE;
     238             :     
     239           0 :     case ScanIntentMod::TEST:
     240           0 :       return CScanIntent::sTEST;
     241             :     
     242           0 :     case ScanIntentMod::UNSPECIFIED:
     243           0 :       return CScanIntent::sUNSPECIFIED;
     244             :     
     245           0 :     case ScanIntentMod::CALIBRATE_ANTENNA_POSITION:
     246           0 :       return CScanIntent::sCALIBRATE_ANTENNA_POSITION;
     247             :     
     248           0 :     case ScanIntentMod::CALIBRATE_ANTENNA_PHASE:
     249           0 :       return CScanIntent::sCALIBRATE_ANTENNA_PHASE;
     250             :     
     251           0 :     case ScanIntentMod::MEASURE_RFI:
     252           0 :       return CScanIntent::sMEASURE_RFI;
     253             :     
     254           0 :     case ScanIntentMod::CALIBRATE_ANTENNA_POINTING_MODEL:
     255           0 :       return CScanIntent::sCALIBRATE_ANTENNA_POINTING_MODEL;
     256             :     
     257           0 :     case ScanIntentMod::SYSTEM_CONFIGURATION:
     258           0 :       return CScanIntent::sSYSTEM_CONFIGURATION;
     259             :     
     260           0 :     case ScanIntentMod::CALIBRATE_APPPHASE_ACTIVE:
     261           0 :       return CScanIntent::sCALIBRATE_APPPHASE_ACTIVE;
     262             :     
     263           0 :     case ScanIntentMod::CALIBRATE_APPPHASE_PASSIVE:
     264           0 :       return CScanIntent::sCALIBRATE_APPPHASE_PASSIVE;
     265             :     
     266           0 :     case ScanIntentMod::OBSERVE_CHECK_SOURCE:
     267           0 :       return CScanIntent::sOBSERVE_CHECK_SOURCE;
     268             :     
     269           0 :     case ScanIntentMod::CALIBRATE_DIFFGAIN:
     270           0 :       return CScanIntent::sCALIBRATE_DIFFGAIN;
     271             :         
     272             :     }
     273             :     // Impossible siutation but....who knows with C++ enums
     274           0 :     throw badInt((int) f);
     275             : }
     276             : 
     277        2999 : ScanIntentMod::ScanIntent CScanIntent::newScanIntent(const std::string& name) {
     278             :                 
     279        2999 :     if (name == CScanIntent::sCALIBRATE_AMPLI) {
     280          91 :         return ScanIntentMod::CALIBRATE_AMPLI;
     281             :     }
     282             :         
     283        2908 :     if (name == CScanIntent::sCALIBRATE_ATMOSPHERE) {
     284         195 :         return ScanIntentMod::CALIBRATE_ATMOSPHERE;
     285             :     }
     286             :         
     287        2713 :     if (name == CScanIntent::sCALIBRATE_BANDPASS) {
     288          42 :         return ScanIntentMod::CALIBRATE_BANDPASS;
     289             :     }
     290             :         
     291        2671 :     if (name == CScanIntent::sCALIBRATE_DELAY) {
     292          51 :         return ScanIntentMod::CALIBRATE_DELAY;
     293             :     }
     294             :         
     295        2620 :     if (name == CScanIntent::sCALIBRATE_FLUX) {
     296          42 :         return ScanIntentMod::CALIBRATE_FLUX;
     297             :     }
     298             :         
     299        2578 :     if (name == CScanIntent::sCALIBRATE_FOCUS) {
     300          16 :         return ScanIntentMod::CALIBRATE_FOCUS;
     301             :     }
     302             :         
     303        2562 :     if (name == CScanIntent::sCALIBRATE_FOCUS_X) {
     304          16 :         return ScanIntentMod::CALIBRATE_FOCUS_X;
     305             :     }
     306             :         
     307        2546 :     if (name == CScanIntent::sCALIBRATE_FOCUS_Y) {
     308          16 :         return ScanIntentMod::CALIBRATE_FOCUS_Y;
     309             :     }
     310             :         
     311        2530 :     if (name == CScanIntent::sCALIBRATE_PHASE) {
     312         422 :         return ScanIntentMod::CALIBRATE_PHASE;
     313             :     }
     314             :         
     315        2108 :     if (name == CScanIntent::sCALIBRATE_POINTING) {
     316         112 :         return ScanIntentMod::CALIBRATE_POINTING;
     317             :     }
     318             :         
     319        1996 :     if (name == CScanIntent::sCALIBRATE_POLARIZATION) {
     320           0 :         return ScanIntentMod::CALIBRATE_POLARIZATION;
     321             :     }
     322             :         
     323        1996 :     if (name == CScanIntent::sCALIBRATE_SIDEBAND_RATIO) {
     324          27 :         return ScanIntentMod::CALIBRATE_SIDEBAND_RATIO;
     325             :     }
     326             :         
     327        1969 :     if (name == CScanIntent::sCALIBRATE_WVR) {
     328        1151 :         return ScanIntentMod::CALIBRATE_WVR;
     329             :     }
     330             :         
     331         818 :     if (name == CScanIntent::sDO_SKYDIP) {
     332           0 :         return ScanIntentMod::DO_SKYDIP;
     333             :     }
     334             :         
     335         818 :     if (name == CScanIntent::sMAP_ANTENNA_SURFACE) {
     336           0 :         return ScanIntentMod::MAP_ANTENNA_SURFACE;
     337             :     }
     338             :         
     339         818 :     if (name == CScanIntent::sMAP_PRIMARY_BEAM) {
     340           0 :         return ScanIntentMod::MAP_PRIMARY_BEAM;
     341             :     }
     342             :         
     343         818 :     if (name == CScanIntent::sOBSERVE_TARGET) {
     344         796 :         return ScanIntentMod::OBSERVE_TARGET;
     345             :     }
     346             :         
     347          22 :     if (name == CScanIntent::sCALIBRATE_POL_LEAKAGE) {
     348           0 :         return ScanIntentMod::CALIBRATE_POL_LEAKAGE;
     349             :     }
     350             :         
     351          22 :     if (name == CScanIntent::sCALIBRATE_POL_ANGLE) {
     352           0 :         return ScanIntentMod::CALIBRATE_POL_ANGLE;
     353             :     }
     354             :         
     355          22 :     if (name == CScanIntent::sTEST) {
     356           0 :         return ScanIntentMod::TEST;
     357             :     }
     358             :         
     359          22 :     if (name == CScanIntent::sUNSPECIFIED) {
     360           0 :         return ScanIntentMod::UNSPECIFIED;
     361             :     }
     362             :         
     363          22 :     if (name == CScanIntent::sCALIBRATE_ANTENNA_POSITION) {
     364           0 :         return ScanIntentMod::CALIBRATE_ANTENNA_POSITION;
     365             :     }
     366             :         
     367          22 :     if (name == CScanIntent::sCALIBRATE_ANTENNA_PHASE) {
     368           0 :         return ScanIntentMod::CALIBRATE_ANTENNA_PHASE;
     369             :     }
     370             :         
     371          22 :     if (name == CScanIntent::sMEASURE_RFI) {
     372           0 :         return ScanIntentMod::MEASURE_RFI;
     373             :     }
     374             :         
     375          22 :     if (name == CScanIntent::sCALIBRATE_ANTENNA_POINTING_MODEL) {
     376           0 :         return ScanIntentMod::CALIBRATE_ANTENNA_POINTING_MODEL;
     377             :     }
     378             :         
     379          22 :     if (name == CScanIntent::sSYSTEM_CONFIGURATION) {
     380          22 :         return ScanIntentMod::SYSTEM_CONFIGURATION;
     381             :     }
     382             :         
     383           0 :     if (name == CScanIntent::sCALIBRATE_APPPHASE_ACTIVE) {
     384           0 :         return ScanIntentMod::CALIBRATE_APPPHASE_ACTIVE;
     385             :     }
     386             :         
     387           0 :     if (name == CScanIntent::sCALIBRATE_APPPHASE_PASSIVE) {
     388           0 :         return ScanIntentMod::CALIBRATE_APPPHASE_PASSIVE;
     389             :     }
     390             :         
     391           0 :     if (name == CScanIntent::sOBSERVE_CHECK_SOURCE) {
     392           0 :         return ScanIntentMod::OBSERVE_CHECK_SOURCE;
     393             :     }
     394             :         
     395           0 :     if (name == CScanIntent::sCALIBRATE_DIFFGAIN) {
     396           0 :         return ScanIntentMod::CALIBRATE_DIFFGAIN;
     397             :     }
     398             :     
     399           0 :     throw badString(name);
     400             : }
     401             : 
     402           0 : ScanIntentMod::ScanIntent CScanIntent::literal(const std::string& name) {
     403             :                 
     404           0 :     if (name == CScanIntent::sCALIBRATE_AMPLI) {
     405           0 :         return ScanIntentMod::CALIBRATE_AMPLI;
     406             :     }
     407             :         
     408           0 :     if (name == CScanIntent::sCALIBRATE_ATMOSPHERE) {
     409           0 :         return ScanIntentMod::CALIBRATE_ATMOSPHERE;
     410             :     }
     411             :         
     412           0 :     if (name == CScanIntent::sCALIBRATE_BANDPASS) {
     413           0 :         return ScanIntentMod::CALIBRATE_BANDPASS;
     414             :     }
     415             :         
     416           0 :     if (name == CScanIntent::sCALIBRATE_DELAY) {
     417           0 :         return ScanIntentMod::CALIBRATE_DELAY;
     418             :     }
     419             :         
     420           0 :     if (name == CScanIntent::sCALIBRATE_FLUX) {
     421           0 :         return ScanIntentMod::CALIBRATE_FLUX;
     422             :     }
     423             :         
     424           0 :     if (name == CScanIntent::sCALIBRATE_FOCUS) {
     425           0 :         return ScanIntentMod::CALIBRATE_FOCUS;
     426             :     }
     427             :         
     428           0 :     if (name == CScanIntent::sCALIBRATE_FOCUS_X) {
     429           0 :         return ScanIntentMod::CALIBRATE_FOCUS_X;
     430             :     }
     431             :         
     432           0 :     if (name == CScanIntent::sCALIBRATE_FOCUS_Y) {
     433           0 :         return ScanIntentMod::CALIBRATE_FOCUS_Y;
     434             :     }
     435             :         
     436           0 :     if (name == CScanIntent::sCALIBRATE_PHASE) {
     437           0 :         return ScanIntentMod::CALIBRATE_PHASE;
     438             :     }
     439             :         
     440           0 :     if (name == CScanIntent::sCALIBRATE_POINTING) {
     441           0 :         return ScanIntentMod::CALIBRATE_POINTING;
     442             :     }
     443             :         
     444           0 :     if (name == CScanIntent::sCALIBRATE_POLARIZATION) {
     445           0 :         return ScanIntentMod::CALIBRATE_POLARIZATION;
     446             :     }
     447             :         
     448           0 :     if (name == CScanIntent::sCALIBRATE_SIDEBAND_RATIO) {
     449           0 :         return ScanIntentMod::CALIBRATE_SIDEBAND_RATIO;
     450             :     }
     451             :         
     452           0 :     if (name == CScanIntent::sCALIBRATE_WVR) {
     453           0 :         return ScanIntentMod::CALIBRATE_WVR;
     454             :     }
     455             :         
     456           0 :     if (name == CScanIntent::sDO_SKYDIP) {
     457           0 :         return ScanIntentMod::DO_SKYDIP;
     458             :     }
     459             :         
     460           0 :     if (name == CScanIntent::sMAP_ANTENNA_SURFACE) {
     461           0 :         return ScanIntentMod::MAP_ANTENNA_SURFACE;
     462             :     }
     463             :         
     464           0 :     if (name == CScanIntent::sMAP_PRIMARY_BEAM) {
     465           0 :         return ScanIntentMod::MAP_PRIMARY_BEAM;
     466             :     }
     467             :         
     468           0 :     if (name == CScanIntent::sOBSERVE_TARGET) {
     469           0 :         return ScanIntentMod::OBSERVE_TARGET;
     470             :     }
     471             :         
     472           0 :     if (name == CScanIntent::sCALIBRATE_POL_LEAKAGE) {
     473           0 :         return ScanIntentMod::CALIBRATE_POL_LEAKAGE;
     474             :     }
     475             :         
     476           0 :     if (name == CScanIntent::sCALIBRATE_POL_ANGLE) {
     477           0 :         return ScanIntentMod::CALIBRATE_POL_ANGLE;
     478             :     }
     479             :         
     480           0 :     if (name == CScanIntent::sTEST) {
     481           0 :         return ScanIntentMod::TEST;
     482             :     }
     483             :         
     484           0 :     if (name == CScanIntent::sUNSPECIFIED) {
     485           0 :         return ScanIntentMod::UNSPECIFIED;
     486             :     }
     487             :         
     488           0 :     if (name == CScanIntent::sCALIBRATE_ANTENNA_POSITION) {
     489           0 :         return ScanIntentMod::CALIBRATE_ANTENNA_POSITION;
     490             :     }
     491             :         
     492           0 :     if (name == CScanIntent::sCALIBRATE_ANTENNA_PHASE) {
     493           0 :         return ScanIntentMod::CALIBRATE_ANTENNA_PHASE;
     494             :     }
     495             :         
     496           0 :     if (name == CScanIntent::sMEASURE_RFI) {
     497           0 :         return ScanIntentMod::MEASURE_RFI;
     498             :     }
     499             :         
     500           0 :     if (name == CScanIntent::sCALIBRATE_ANTENNA_POINTING_MODEL) {
     501           0 :         return ScanIntentMod::CALIBRATE_ANTENNA_POINTING_MODEL;
     502             :     }
     503             :         
     504           0 :     if (name == CScanIntent::sSYSTEM_CONFIGURATION) {
     505           0 :         return ScanIntentMod::SYSTEM_CONFIGURATION;
     506             :     }
     507             :         
     508           0 :     if (name == CScanIntent::sCALIBRATE_APPPHASE_ACTIVE) {
     509           0 :         return ScanIntentMod::CALIBRATE_APPPHASE_ACTIVE;
     510             :     }
     511             :         
     512           0 :     if (name == CScanIntent::sCALIBRATE_APPPHASE_PASSIVE) {
     513           0 :         return ScanIntentMod::CALIBRATE_APPPHASE_PASSIVE;
     514             :     }
     515             :         
     516           0 :     if (name == CScanIntent::sOBSERVE_CHECK_SOURCE) {
     517           0 :         return ScanIntentMod::OBSERVE_CHECK_SOURCE;
     518             :     }
     519             :         
     520           0 :     if (name == CScanIntent::sCALIBRATE_DIFFGAIN) {
     521           0 :         return ScanIntentMod::CALIBRATE_DIFFGAIN;
     522             :     }
     523             :     
     524           0 :     throw badString(name);
     525             : }
     526             : 
     527           0 : ScanIntentMod::ScanIntent CScanIntent::from_int(unsigned int i) {
     528           0 :         vector<string> names_ = names();
     529           0 :         if (i >= names_.size()) throw badInt(i);
     530           0 :         return newScanIntent(names_.at(i));
     531           0 : }
     532             : 
     533           0 : string CScanIntent::badString(const string& name) {
     534           0 :         return "'"+name+"' does not correspond to any literal in the enumeration 'ScanIntent'.";
     535             : }
     536             : 
     537           0 : string CScanIntent::badInt(unsigned int i) {
     538           0 :         ostringstream oss ;
     539           0 :         oss << "'" << i << "' is out of range for the enumeration 'ScanIntent'.";
     540           0 :         return oss.str();
     541           0 : }
     542             : 
     543             : namespace ScanIntentMod {
     544           0 :         std::ostream & operator << ( std::ostream & out, const ScanIntent& value) {
     545           0 :                 out << CScanIntent::name(value);
     546           0 :                 return out;
     547             :         }
     548             : 
     549           0 :         std::istream & operator >> ( std::istream & in , ScanIntent& value ) {
     550           0 :                 in.clear();
     551           0 :                 string s ; 
     552           0 :                 in >> s;
     553             :                 try {
     554           0 :                 value = CScanIntent::literal(s);
     555             :                 }
     556           0 :                 catch (string & m) {
     557           0 :                 in.setstate(ios::failbit);
     558           0 :                 }
     559           0 :                 return in;
     560           0 :         }
     561             : }
     562             :