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 CReceiverBand.cpp
      34             :  */
      35             : #include <sstream>
      36             : #include <alma/Enumerations/CReceiverBand.h>
      37             : #include <string>
      38             : using namespace std;
      39             : 
      40           0 : int CReceiverBand::version() {
      41           0 :         return ReceiverBandMod::version;
      42             :         }
      43             :         
      44           0 : string CReceiverBand::revision () {
      45           0 :         return ReceiverBandMod::revision;
      46             : }
      47             : 
      48           0 : unsigned int CReceiverBand::size() {
      49           0 :         return 27;
      50             :         }
      51             :         
      52             :         
      53             : const std::string& CReceiverBand::sALMA_RB_01 = "ALMA_RB_01";
      54             :         
      55             : const std::string& CReceiverBand::sALMA_RB_02 = "ALMA_RB_02";
      56             :         
      57             : const std::string& CReceiverBand::sALMA_RB_03 = "ALMA_RB_03";
      58             :         
      59             : const std::string& CReceiverBand::sALMA_RB_04 = "ALMA_RB_04";
      60             :         
      61             : const std::string& CReceiverBand::sALMA_RB_05 = "ALMA_RB_05";
      62             :         
      63             : const std::string& CReceiverBand::sALMA_RB_06 = "ALMA_RB_06";
      64             :         
      65             : const std::string& CReceiverBand::sALMA_RB_07 = "ALMA_RB_07";
      66             :         
      67             : const std::string& CReceiverBand::sALMA_RB_08 = "ALMA_RB_08";
      68             :         
      69             : const std::string& CReceiverBand::sALMA_RB_09 = "ALMA_RB_09";
      70             :         
      71             : const std::string& CReceiverBand::sALMA_RB_10 = "ALMA_RB_10";
      72             :         
      73             : const std::string& CReceiverBand::sALMA_RB_ALL = "ALMA_RB_ALL";
      74             :         
      75             : const std::string& CReceiverBand::sALMA_HOLOGRAPHY_RECEIVER = "ALMA_HOLOGRAPHY_RECEIVER";
      76             :         
      77             : const std::string& CReceiverBand::sBURE_01 = "BURE_01";
      78             :         
      79             : const std::string& CReceiverBand::sBURE_02 = "BURE_02";
      80             :         
      81             : const std::string& CReceiverBand::sBURE_03 = "BURE_03";
      82             :         
      83             : const std::string& CReceiverBand::sBURE_04 = "BURE_04";
      84             :         
      85             : const std::string& CReceiverBand::sEVLA_4 = "EVLA_4";
      86             :         
      87             : const std::string& CReceiverBand::sEVLA_P = "EVLA_P";
      88             :         
      89             : const std::string& CReceiverBand::sEVLA_L = "EVLA_L";
      90             :         
      91             : const std::string& CReceiverBand::sEVLA_C = "EVLA_C";
      92             :         
      93             : const std::string& CReceiverBand::sEVLA_S = "EVLA_S";
      94             :         
      95             : const std::string& CReceiverBand::sEVLA_X = "EVLA_X";
      96             :         
      97             : const std::string& CReceiverBand::sEVLA_Ku = "EVLA_Ku";
      98             :         
      99             : const std::string& CReceiverBand::sEVLA_K = "EVLA_K";
     100             :         
     101             : const std::string& CReceiverBand::sEVLA_Ka = "EVLA_Ka";
     102             :         
     103             : const std::string& CReceiverBand::sEVLA_Q = "EVLA_Q";
     104             :         
     105             : const std::string& CReceiverBand::sUNSPECIFIED = "UNSPECIFIED";
     106             :         
     107        6577 : const std::vector<std::string> CReceiverBand::names() {
     108        6577 :     std::vector<std::string> enumSet;
     109             :     
     110        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sALMA_RB_01);
     111             :     
     112        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sALMA_RB_02);
     113             :     
     114        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sALMA_RB_03);
     115             :     
     116        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sALMA_RB_04);
     117             :     
     118        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sALMA_RB_05);
     119             :     
     120        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sALMA_RB_06);
     121             :     
     122        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sALMA_RB_07);
     123             :     
     124        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sALMA_RB_08);
     125             :     
     126        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sALMA_RB_09);
     127             :     
     128        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sALMA_RB_10);
     129             :     
     130        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sALMA_RB_ALL);
     131             :     
     132        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sALMA_HOLOGRAPHY_RECEIVER);
     133             :     
     134        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sBURE_01);
     135             :     
     136        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sBURE_02);
     137             :     
     138        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sBURE_03);
     139             :     
     140        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sBURE_04);
     141             :     
     142        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sEVLA_4);
     143             :     
     144        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sEVLA_P);
     145             :     
     146        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sEVLA_L);
     147             :     
     148        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sEVLA_C);
     149             :     
     150        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sEVLA_S);
     151             :     
     152        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sEVLA_X);
     153             :     
     154        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sEVLA_Ku);
     155             :     
     156        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sEVLA_K);
     157             :     
     158        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sEVLA_Ka);
     159             :     
     160        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sEVLA_Q);
     161             :     
     162        6577 :     enumSet.insert(enumSet.end(), CReceiverBand::sUNSPECIFIED);
     163             :         
     164        6577 :     return enumSet;
     165             : }
     166             : 
     167         816 : std::string CReceiverBand::name(const ReceiverBandMod::ReceiverBand& f) {
     168         816 :     switch (f) {
     169             :     
     170           0 :     case ReceiverBandMod::ALMA_RB_01:
     171           0 :       return CReceiverBand::sALMA_RB_01;
     172             :     
     173           0 :     case ReceiverBandMod::ALMA_RB_02:
     174           0 :       return CReceiverBand::sALMA_RB_02;
     175             :     
     176           0 :     case ReceiverBandMod::ALMA_RB_03:
     177           0 :       return CReceiverBand::sALMA_RB_03;
     178             :     
     179           0 :     case ReceiverBandMod::ALMA_RB_04:
     180           0 :       return CReceiverBand::sALMA_RB_04;
     181             :     
     182           0 :     case ReceiverBandMod::ALMA_RB_05:
     183           0 :       return CReceiverBand::sALMA_RB_05;
     184             :     
     185         129 :     case ReceiverBandMod::ALMA_RB_06:
     186         129 :       return CReceiverBand::sALMA_RB_06;
     187             :     
     188         282 :     case ReceiverBandMod::ALMA_RB_07:
     189         282 :       return CReceiverBand::sALMA_RB_07;
     190             :     
     191           0 :     case ReceiverBandMod::ALMA_RB_08:
     192           0 :       return CReceiverBand::sALMA_RB_08;
     193             :     
     194         276 :     case ReceiverBandMod::ALMA_RB_09:
     195         276 :       return CReceiverBand::sALMA_RB_09;
     196             :     
     197           0 :     case ReceiverBandMod::ALMA_RB_10:
     198           0 :       return CReceiverBand::sALMA_RB_10;
     199             :     
     200           0 :     case ReceiverBandMod::ALMA_RB_ALL:
     201           0 :       return CReceiverBand::sALMA_RB_ALL;
     202             :     
     203           0 :     case ReceiverBandMod::ALMA_HOLOGRAPHY_RECEIVER:
     204           0 :       return CReceiverBand::sALMA_HOLOGRAPHY_RECEIVER;
     205             :     
     206           0 :     case ReceiverBandMod::BURE_01:
     207           0 :       return CReceiverBand::sBURE_01;
     208             :     
     209           0 :     case ReceiverBandMod::BURE_02:
     210           0 :       return CReceiverBand::sBURE_02;
     211             :     
     212           0 :     case ReceiverBandMod::BURE_03:
     213           0 :       return CReceiverBand::sBURE_03;
     214             :     
     215           0 :     case ReceiverBandMod::BURE_04:
     216           0 :       return CReceiverBand::sBURE_04;
     217             :     
     218           0 :     case ReceiverBandMod::EVLA_4:
     219           0 :       return CReceiverBand::sEVLA_4;
     220             :     
     221           0 :     case ReceiverBandMod::EVLA_P:
     222           0 :       return CReceiverBand::sEVLA_P;
     223             :     
     224           0 :     case ReceiverBandMod::EVLA_L:
     225           0 :       return CReceiverBand::sEVLA_L;
     226             :     
     227           0 :     case ReceiverBandMod::EVLA_C:
     228           0 :       return CReceiverBand::sEVLA_C;
     229             :     
     230           0 :     case ReceiverBandMod::EVLA_S:
     231           0 :       return CReceiverBand::sEVLA_S;
     232             :     
     233          51 :     case ReceiverBandMod::EVLA_X:
     234          51 :       return CReceiverBand::sEVLA_X;
     235             :     
     236           0 :     case ReceiverBandMod::EVLA_Ku:
     237           0 :       return CReceiverBand::sEVLA_Ku;
     238             :     
     239           0 :     case ReceiverBandMod::EVLA_K:
     240           0 :       return CReceiverBand::sEVLA_K;
     241             :     
     242           0 :     case ReceiverBandMod::EVLA_Ka:
     243           0 :       return CReceiverBand::sEVLA_Ka;
     244             :     
     245           0 :     case ReceiverBandMod::EVLA_Q:
     246           0 :       return CReceiverBand::sEVLA_Q;
     247             :     
     248          78 :     case ReceiverBandMod::UNSPECIFIED:
     249          78 :       return CReceiverBand::sUNSPECIFIED;
     250             :         
     251             :     }
     252             :     // Impossible siutation but....who knows with C++ enums
     253           0 :     throw badInt((int) f);
     254             : }
     255             : 
     256        6719 : ReceiverBandMod::ReceiverBand CReceiverBand::newReceiverBand(const std::string& name) {
     257             :                 
     258        6719 :     if (name == CReceiverBand::sALMA_RB_01) {
     259        6577 :         return ReceiverBandMod::ALMA_RB_01;
     260             :     }
     261             :         
     262         142 :     if (name == CReceiverBand::sALMA_RB_02) {
     263           0 :         return ReceiverBandMod::ALMA_RB_02;
     264             :     }
     265             :         
     266         142 :     if (name == CReceiverBand::sALMA_RB_03) {
     267           8 :         return ReceiverBandMod::ALMA_RB_03;
     268             :     }
     269             :         
     270         134 :     if (name == CReceiverBand::sALMA_RB_04) {
     271           0 :         return ReceiverBandMod::ALMA_RB_04;
     272             :     }
     273             :         
     274         134 :     if (name == CReceiverBand::sALMA_RB_05) {
     275           0 :         return ReceiverBandMod::ALMA_RB_05;
     276             :     }
     277             :         
     278         134 :     if (name == CReceiverBand::sALMA_RB_06) {
     279          24 :         return ReceiverBandMod::ALMA_RB_06;
     280             :     }
     281             :         
     282         110 :     if (name == CReceiverBand::sALMA_RB_07) {
     283           0 :         return ReceiverBandMod::ALMA_RB_07;
     284             :     }
     285             :         
     286         110 :     if (name == CReceiverBand::sALMA_RB_08) {
     287           0 :         return ReceiverBandMod::ALMA_RB_08;
     288             :     }
     289             :         
     290         110 :     if (name == CReceiverBand::sALMA_RB_09) {
     291          72 :         return ReceiverBandMod::ALMA_RB_09;
     292             :     }
     293             :         
     294          38 :     if (name == CReceiverBand::sALMA_RB_10) {
     295           0 :         return ReceiverBandMod::ALMA_RB_10;
     296             :     }
     297             :         
     298          38 :     if (name == CReceiverBand::sALMA_RB_ALL) {
     299           0 :         return ReceiverBandMod::ALMA_RB_ALL;
     300             :     }
     301             :         
     302          38 :     if (name == CReceiverBand::sALMA_HOLOGRAPHY_RECEIVER) {
     303           0 :         return ReceiverBandMod::ALMA_HOLOGRAPHY_RECEIVER;
     304             :     }
     305             :         
     306          38 :     if (name == CReceiverBand::sBURE_01) {
     307           0 :         return ReceiverBandMod::BURE_01;
     308             :     }
     309             :         
     310          38 :     if (name == CReceiverBand::sBURE_02) {
     311           0 :         return ReceiverBandMod::BURE_02;
     312             :     }
     313             :         
     314          38 :     if (name == CReceiverBand::sBURE_03) {
     315           0 :         return ReceiverBandMod::BURE_03;
     316             :     }
     317             :         
     318          38 :     if (name == CReceiverBand::sBURE_04) {
     319           0 :         return ReceiverBandMod::BURE_04;
     320             :     }
     321             :         
     322          38 :     if (name == CReceiverBand::sEVLA_4) {
     323           0 :         return ReceiverBandMod::EVLA_4;
     324             :     }
     325             :         
     326          38 :     if (name == CReceiverBand::sEVLA_P) {
     327           0 :         return ReceiverBandMod::EVLA_P;
     328             :     }
     329             :         
     330          38 :     if (name == CReceiverBand::sEVLA_L) {
     331           0 :         return ReceiverBandMod::EVLA_L;
     332             :     }
     333             :         
     334          38 :     if (name == CReceiverBand::sEVLA_C) {
     335           0 :         return ReceiverBandMod::EVLA_C;
     336             :     }
     337             :         
     338          38 :     if (name == CReceiverBand::sEVLA_S) {
     339           0 :         return ReceiverBandMod::EVLA_S;
     340             :     }
     341             :         
     342          38 :     if (name == CReceiverBand::sEVLA_X) {
     343           1 :         return ReceiverBandMod::EVLA_X;
     344             :     }
     345             :         
     346          37 :     if (name == CReceiverBand::sEVLA_Ku) {
     347           0 :         return ReceiverBandMod::EVLA_Ku;
     348             :     }
     349             :         
     350          37 :     if (name == CReceiverBand::sEVLA_K) {
     351           0 :         return ReceiverBandMod::EVLA_K;
     352             :     }
     353             :         
     354          37 :     if (name == CReceiverBand::sEVLA_Ka) {
     355           0 :         return ReceiverBandMod::EVLA_Ka;
     356             :     }
     357             :         
     358          37 :     if (name == CReceiverBand::sEVLA_Q) {
     359           0 :         return ReceiverBandMod::EVLA_Q;
     360             :     }
     361             :         
     362          37 :     if (name == CReceiverBand::sUNSPECIFIED) {
     363          37 :         return ReceiverBandMod::UNSPECIFIED;
     364             :     }
     365             :     
     366           0 :     throw badString(name);
     367             : }
     368             : 
     369           0 : ReceiverBandMod::ReceiverBand CReceiverBand::literal(const std::string& name) {
     370             :                 
     371           0 :     if (name == CReceiverBand::sALMA_RB_01) {
     372           0 :         return ReceiverBandMod::ALMA_RB_01;
     373             :     }
     374             :         
     375           0 :     if (name == CReceiverBand::sALMA_RB_02) {
     376           0 :         return ReceiverBandMod::ALMA_RB_02;
     377             :     }
     378             :         
     379           0 :     if (name == CReceiverBand::sALMA_RB_03) {
     380           0 :         return ReceiverBandMod::ALMA_RB_03;
     381             :     }
     382             :         
     383           0 :     if (name == CReceiverBand::sALMA_RB_04) {
     384           0 :         return ReceiverBandMod::ALMA_RB_04;
     385             :     }
     386             :         
     387           0 :     if (name == CReceiverBand::sALMA_RB_05) {
     388           0 :         return ReceiverBandMod::ALMA_RB_05;
     389             :     }
     390             :         
     391           0 :     if (name == CReceiverBand::sALMA_RB_06) {
     392           0 :         return ReceiverBandMod::ALMA_RB_06;
     393             :     }
     394             :         
     395           0 :     if (name == CReceiverBand::sALMA_RB_07) {
     396           0 :         return ReceiverBandMod::ALMA_RB_07;
     397             :     }
     398             :         
     399           0 :     if (name == CReceiverBand::sALMA_RB_08) {
     400           0 :         return ReceiverBandMod::ALMA_RB_08;
     401             :     }
     402             :         
     403           0 :     if (name == CReceiverBand::sALMA_RB_09) {
     404           0 :         return ReceiverBandMod::ALMA_RB_09;
     405             :     }
     406             :         
     407           0 :     if (name == CReceiverBand::sALMA_RB_10) {
     408           0 :         return ReceiverBandMod::ALMA_RB_10;
     409             :     }
     410             :         
     411           0 :     if (name == CReceiverBand::sALMA_RB_ALL) {
     412           0 :         return ReceiverBandMod::ALMA_RB_ALL;
     413             :     }
     414             :         
     415           0 :     if (name == CReceiverBand::sALMA_HOLOGRAPHY_RECEIVER) {
     416           0 :         return ReceiverBandMod::ALMA_HOLOGRAPHY_RECEIVER;
     417             :     }
     418             :         
     419           0 :     if (name == CReceiverBand::sBURE_01) {
     420           0 :         return ReceiverBandMod::BURE_01;
     421             :     }
     422             :         
     423           0 :     if (name == CReceiverBand::sBURE_02) {
     424           0 :         return ReceiverBandMod::BURE_02;
     425             :     }
     426             :         
     427           0 :     if (name == CReceiverBand::sBURE_03) {
     428           0 :         return ReceiverBandMod::BURE_03;
     429             :     }
     430             :         
     431           0 :     if (name == CReceiverBand::sBURE_04) {
     432           0 :         return ReceiverBandMod::BURE_04;
     433             :     }
     434             :         
     435           0 :     if (name == CReceiverBand::sEVLA_4) {
     436           0 :         return ReceiverBandMod::EVLA_4;
     437             :     }
     438             :         
     439           0 :     if (name == CReceiverBand::sEVLA_P) {
     440           0 :         return ReceiverBandMod::EVLA_P;
     441             :     }
     442             :         
     443           0 :     if (name == CReceiverBand::sEVLA_L) {
     444           0 :         return ReceiverBandMod::EVLA_L;
     445             :     }
     446             :         
     447           0 :     if (name == CReceiverBand::sEVLA_C) {
     448           0 :         return ReceiverBandMod::EVLA_C;
     449             :     }
     450             :         
     451           0 :     if (name == CReceiverBand::sEVLA_S) {
     452           0 :         return ReceiverBandMod::EVLA_S;
     453             :     }
     454             :         
     455           0 :     if (name == CReceiverBand::sEVLA_X) {
     456           0 :         return ReceiverBandMod::EVLA_X;
     457             :     }
     458             :         
     459           0 :     if (name == CReceiverBand::sEVLA_Ku) {
     460           0 :         return ReceiverBandMod::EVLA_Ku;
     461             :     }
     462             :         
     463           0 :     if (name == CReceiverBand::sEVLA_K) {
     464           0 :         return ReceiverBandMod::EVLA_K;
     465             :     }
     466             :         
     467           0 :     if (name == CReceiverBand::sEVLA_Ka) {
     468           0 :         return ReceiverBandMod::EVLA_Ka;
     469             :     }
     470             :         
     471           0 :     if (name == CReceiverBand::sEVLA_Q) {
     472           0 :         return ReceiverBandMod::EVLA_Q;
     473             :     }
     474             :         
     475           0 :     if (name == CReceiverBand::sUNSPECIFIED) {
     476           0 :         return ReceiverBandMod::UNSPECIFIED;
     477             :     }
     478             :     
     479           0 :     throw badString(name);
     480             : }
     481             : 
     482        6577 : ReceiverBandMod::ReceiverBand CReceiverBand::from_int(unsigned int i) {
     483       13154 :         vector<string> names_ = names();
     484        6577 :         if (i >= names_.size()) throw badInt(i);
     485       13154 :         return newReceiverBand(names_.at(i));
     486             : }
     487             : 
     488           0 : string CReceiverBand::badString(const string& name) {
     489           0 :         return "'"+name+"' does not correspond to any literal in the enumeration 'ReceiverBand'.";
     490             : }
     491             : 
     492           0 : string CReceiverBand::badInt(unsigned int i) {
     493           0 :         ostringstream oss ;
     494           0 :         oss << "'" << i << "' is out of range for the enumeration 'ReceiverBand'.";
     495           0 :         return oss.str();
     496             : }
     497             : 
     498             : namespace ReceiverBandMod {
     499           0 :         std::ostream & operator << ( std::ostream & out, const ReceiverBand& value) {
     500           0 :                 out << CReceiverBand::name(value);
     501           0 :                 return out;
     502             :         }
     503             : 
     504           0 :         std::istream & operator >> ( std::istream & in , ReceiverBand& value ) {
     505           0 :                 in.clear();
     506           0 :                 string s ; 
     507           0 :                 in >> s;
     508             :                 try {
     509           0 :                 value = CReceiverBand::literal(s);
     510             :                 }
     511           0 :                 catch (string & m) {
     512           0 :                 in.setstate(ios::failbit);
     513             :                 }
     514           0 :                 return in;
     515             :         }
     516             : }
     517             :