GyotoFactory.h

Go to the documentation of this file.

#ifdef GYOTO_USE_XERCES

/*
    Copyright 2011-2014, 2016, 2018 Thibaut Paumard, Frederic Vincent

    This file is part of Gyoto.

    Gyoto 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 3 of the License, or
    (at your option) any later version.

    Gyoto is 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.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Gyoto.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef __GyotoFactory_H_
#define __GyotoFactory_H_

#include <vector>

#include "GyotoConfig.h"


#ifndef XERCES_INCLUDE_WCHAR_H
#define XERCES_INCLUDE_WCHAR_H 0
#endif

#include <xercesc/sax/ErrorHandler.hpp>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/parsers/XercesDOMParser.hpp>
#include <GyotoScenery.h>
#include <GyotoPhoton.h>
#include <GyotoSpectrum.h>
#include <sstream>
#include <string>

namespace Gyoto {
  class Factory;
  class FactoryMessenger;
  namespace Spectrometer {
    class Generic;
    class Uniform;
  }
}

class Gyoto::Factory
{
  friend class Gyoto::FactoryMessenger;

 protected:
  // XERCES MACHINERY
  xercesc::ErrorHandler *reporter_;
  xercesc::DOMDocument *doc_;
  xercesc::DOMElement *root_;
  xercesc::XercesDOMParser *parser_;
  xercesc::DOMXPathNSResolver* resolver_;
  xercesc::DOMImplementation* impl_;

  // Elements which must happen only once in a file
  // but may happen about anywhere
  xercesc::DOMElement *gg_el_;
  xercesc::DOMElement *obj_el_;
  xercesc::DOMElement *ph_el_;

  // GYOTO elements
  SmartPointer<Scenery> scenery_;
  SmartPointer<Metric::Generic> gg_;
  SmartPointer<Screen> screen_; 
  SmartPointer<Astrobj::Generic> obj_;
  SmartPointer<Photon> photon_;
  SmartPointer<Spectrometer::Generic> spectro_;

  // Factory stuff
  std::string filename_;
  std::string kind_;

 public:

  Factory(char * filename);

  Factory(SmartPointer<Scenery> sc);
  Factory(SmartPointer<Metric::Generic> gg);
  Factory(SmartPointer<Astrobj::Generic> ao);
  Factory(SmartPointer<Spectrum::Generic> sp);
  Factory(SmartPointer<Screen> screen);
  Factory(SmartPointer<Photon> photon);
  Factory(SmartPointer<Spectrometer::Generic> Spectrometer);

  ~Factory();

 private:
  void setReporter(xercesc::ErrorHandler*);
  xercesc::DOMElement * getRoot();
  xercesc::DOMDocument* getDoc();

 public:
  const std::string kind();


  Gyoto::SmartPointer<Gyoto::Scenery> scenery();


  Gyoto::SmartPointer<Gyoto::Metric::Generic>  metric();


  Gyoto::SmartPointer<Gyoto::Screen>  screen();


  Gyoto::SmartPointer<Gyoto::Astrobj::Generic> astrobj();


  Gyoto::SmartPointer<Gyoto::Photon>  photon();


  Gyoto::SmartPointer<Gyoto::Spectrum::Generic>  spectrum();


  Gyoto::SmartPointer<Gyoto::Spectrometer::Generic>  spectrometer();

  // XML OUTPUT
  void write(const char* const fname=0);

  std::string format();

  // Setting elements

  void metric(SmartPointer<Metric::Generic> gg, xercesc::DOMElement *el);


  void astrobj(SmartPointer<Astrobj::Generic> ao, xercesc::DOMElement *el);


  void screen(SmartPointer<Screen> scr, xercesc::DOMElement *el);

  void setContent(std::string content, xercesc::DOMElement *el);


  void setParameter(std::string name, xercesc::DOMElement *pel);


  void setParameter(std::string name, double value,
                    xercesc::DOMElement *pel);


  void setParameter(std::string name, int value,
                    xercesc::DOMElement *pel);


  void setParameter(std::string name, unsigned int value,
                    xercesc::DOMElement *pel);


  void setParameter(std::string name, long value,
                    xercesc::DOMElement *pel);


  void setParameter(std::string name, unsigned long value,
                    xercesc::DOMElement *pel);


  void setParameter(std::string name, std::string value,
                    xercesc::DOMElement*pel);


  void setParameter(std::string name, double val[], size_t nelem,
                    xercesc::DOMElement* pel,
                    FactoryMessenger **child = NULL);

  void setParameter(std::string name, std::vector<double> const &val,
                    xercesc::DOMElement* pel,
                    FactoryMessenger **child = NULL);

  void setParameter(std::string name, std::vector<unsigned long> const &val,
                    xercesc::DOMElement* pel,
                    FactoryMessenger **child = NULL);


  std::string fullPath(std::string relpath);
};

#endif
#endif