fits_factory.h

Go to the documentation of this file.

/*
Arroyo - software for the simulation of electromagnetic wave propagation
through turbulence and optics.

Copyright (c) 2000-2004 California Institute of Technology.  Written by
Dr. Matthew Britton.  For comments or questions about this software,
please contact the author at mbritton@astro.caltech.edu.

This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as  published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.

This program is provided "as is" and distributed in the hope that it
will be useful, but WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  In no
event shall California Institute of Technology be liable to any party
for direct, indirect, special, incidental or consequential damages,
including lost profits, arising out of the use of this software and its
documentation, even if the California Institute of Technology has been
advised of the possibility of such damage.   The California Institute of
Technology has no obligation to provide maintenance, support, updates,
enhancements or modifications.  See the GNU General Public License for
more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
*/

#ifndef FITS_FACTORY_H
#define FITS_FACTORY_H

#include <map>
#include <string>
#include <vector>
#include <iterator>
#include <iostream>
#include "iofits.h"

namespace Arroyo {

  using std::string;
  using std::vector;
  using std::cerr;
  using std::cout;
  using std::endl;

  class iofits;



  class fits_keyval_entry {

  private:

    fits_keyval_entry(){};

  protected:

    int header_offset;

    string key;
    string val;

  public:

    fits_keyval_entry(const string & k, const string & v, int hdr_offset = 0) {
      if(hdr_offset<0){
        cerr << "fits_keyval_entry::fits_keyval_entry error - "
                  << "could not initialize fits_keyval_entry with header offset "
                  << hdr_offset << endl;
        throw(string("fits_keyval_entry::fits_keyval_entry"));
      }
      header_offset = hdr_offset;
      key = k;
      val = v;
    }

    fits_keyval_entry(const fits_keyval_entry & fkve) {
      this->operator=(fkve);
    }

    ~fits_keyval_entry(){};

    fits_keyval_entry & operator=(const fits_keyval_entry & fkve){
      if(this==&fkve) return(*this);
      header_offset = fkve.header_offset;
      key = fkve.key;
      val = fkve.val;
      return(*this);
    }

    int get_offset() const {return(header_offset);};
    
    string get_key() const {return(key);};

    string get_val() const {return(val);};

    void print(std::ostream & os) const {
      os << "\t" << key << "\t" << val
         << "\tHDU offset " << header_offset << "\t" 
         << endl;
    }

    friend bool operator<(const fits_keyval_entry & kve1, 
                          const fits_keyval_entry & kve2){
      if(kve1.header_offset<kve2.header_offset) return(true);
      return(false);
    }

    friend bool operator==(const fits_keyval_entry &f1, const fits_keyval_entry &f2){
      if(f1.header_offset!=f2.header_offset) return(false);
      if(f1.key!=f2.key) return(false);
      if(f1.val!=f2.val) return(false);
      return(true);
    }
  };



  class fits_keyval_set :
    public vector<fits_keyval_entry> {

  public:

    fits_keyval_set(){}

    fits_keyval_set(const fits_keyval_set & fkvs) {
      this->operator=(fkvs);
    }

    ~fits_keyval_set(){};

    fits_keyval_set & operator=(const fits_keyval_set & fkvs){
      if(this==&fkvs) return(*this);
      this->vector<fits_keyval_entry>::operator=(fkvs);
      return(*this);
    }

    void print(std::ostream & os) const {      
      for(int i=0; i<this->size(); i++)
        (*this)[i].print(os);
    };

    friend bool operator<(const fits_keyval_set & kvs1, 
                          const fits_keyval_set & kvs2){
      return(true);
      /*
      cout << "op<\n";
      if(kvs1.size()<kvs2.size()) return(true);
      for(int i=0; i<kvs1.size(); i++)
        if(kvs1[i]<kvs2[i]) return(true);
      return(false);
      */
    }

    friend bool operator==(const fits_keyval_set &s1, const fits_keyval_set &s2){
      s1.print(cout);
      cout << endl;
      s2.print(cout);
      cout << endl << endl;

      if(s1.size()!=s2.size()) return(false);
      for(int i=0; i<s1.size(); i++)
        if(!(s1[i]==s2[i])) return(false);
      return(true);
    }
  };


  template<class abstract_product>
  class fits_factory {

  private:

    fits_factory(){};

    ~fits_factory(){};

    static fits_factory &instance()
      {
        static fits_factory f;
        return f;
      };
  
    typedef std::map<fits_keyval_set, 
      abstract_product *(*)(const iofits &) > assoc_map;

    assoc_map creators_;

  public:

    static bool Register(const fits_keyval_set &fkvs, 
                         abstract_product *(*creator)(const iofits &) ) {
        
      //typedef std::pair<const std::map<const std::string, std::string>, abstract_product *(*)(const char * )> value_type;
      
      /*
        std::cout << "called register creator\n";
        assoc_map::const_iterator e = instance().creators_.end();
        assoc_map::const_iterator i = instance().creators_.find(fits_keyval_map);
        if(i!=e){
        cout << "keyval map already registered\n";
          throw(string("fits_factory::register"));
          }
      */
        
      //fits_keyval_entries entries(fkves);
      //std::sort(entries.begin(), entries.end());

      //cout << "REGISTERING\n";
      //fkvs.print(cout);

      if(!(instance().creators_.insert(typename assoc_map::value_type(fkvs, creator))).second){
        cerr << "fits_factory::Register error - could not register class\n";
        fkvs.print(cerr);
        throw(string("fits_factory::Register"));
      }
      /*
      cout << "REGISTERED\n";
      typename assoc_map::const_iterator i = instance().creators_.begin();
      while(i!=instance().creators_.end()){
        i->first.print(cout);
        cout << endl << endl;
        i++;
      } 
      */     
      return true;
    }
    
    static abstract_product *create(const iofits & iof) {
      // iterate through the entries in the assoc_map, 
      // checking for a match
      string val, comment;
      typename assoc_map::const_iterator i = instance().creators_.begin();
      bool match;

      //cout << "checking " << instance().creators_.size() << " entries\n";

      while(i!=instance().creators_.end()){
        match = true;

        //cout << "checking " << i->first.size() << " fits_keyval_entries\n";

        fits_keyval_set::const_iterator j = (i->first).begin();
        while(j!=(i->first).end()){
          iof.movrel_hdu(j->get_offset());
          /*
          cout << "checking key x" << j->get_key() << "x"
               << " val x" << j->get_val() << "x"
               << " hdu offset " << j->get_offset()
               << endl;
          */
          if(!iof.key_exists(j->get_key().c_str())){
            //cout << "\tcould not find key " << j->get_key() << endl;
            match = false;
            iof.movrel_hdu(-j->get_offset());
            break;
          }
          // Here if the second entry in the map is empty
          // we assume that the existence of the first
          // key in the header is what the user wants to test.
          // So we skip checking the value
          if(j->get_val().length()){
            iof.read_key(j->get_key().c_str(), val, comment);
            if(j->get_val()!=val){
              //cout << "\tfound val " << val << " rather than val " << j->get_val() << endl;
              match = false;
              iof.movrel_hdu(-j->get_offset());
              break;
            }
          }
          iof.movrel_hdu(-j->get_offset());
          j++;
        }
        if(match) return (i->second)(iof);
        i++;
      }
      cout << "fits_factory_create error - "
           << "could not find matching map in fits header - registered entries:\n\n";
      i = instance().creators_.begin();
      while(i!=instance().creators_.end()){
        i->first.print(cout);
        cout << endl << endl;
        i++;
      }
      throw string("fits_factory::create");
    }    
  };

}
#endif 

---