Line data    Source code

       1             : #include <imageanalysis/ImageAnalysis/ImageHistory.h>
       2             : 
       3             : #include <stdcasa/variant.h>
       4             : #include <iomanip>
       5             : 
       6             : //#include <casa/OS/Time.h>
       7             : 
       8             : namespace casa {
       9             : 
      10           0 : template<class T> ImageHistory<T>::ImageHistory(
      11             :         const SPIIT image
      12           0 : ) : _image(image) {
      13           0 :     ThrowIf(! _image, "Image pointer cannot be null");
      14           0 : }
      15             : 
      16           0 : template<class T> void ImageHistory<T>::addHistory(
      17             :     const String& origin,
      18             :     const String& history
      19             : ) {
      20           0 :     std::vector<String> x { history };
      21             :     //x.push_back(history);
      22           0 :     addHistory(origin, x);
      23           0 : }
      24             : 
      25           0 : template<class T> void ImageHistory<T>::addHistory(
      26             :         const LogOrigin& origin,
      27             :         const String& history
      28             : ) {
      29           0 :     std::vector<String> x { history };
      30             :     // x.push_back(history);
      31           0 :     addHistory(origin.toString(), x);
      32           0 : }
      33             : 
      34           0 : template<class T> void ImageHistory<T>::addHistory(
      35             :     const std::vector<std::pair<LogOrigin, String> >& history
      36             : ) {
      37           0 :     auto& log = _image->logger();
      38             :     //
      39             :     // Make sure we can write into the history table if needed
      40             :     //
      41           0 :     log.reopenRW();
      42           0 :     auto& sink = log.sink();
      43           0 :     for (const auto& el: history) {
      44           0 :         auto x = el.second;
      45           0 :         x.trim();
      46           0 :         if (! x.empty()) {
      47           0 :             LogMessage msg(el.second, el.first);
      48           0 :             sink.postLocally(msg);
      49             :         }
      50             :     }
      51           0 : }
      52             : 
      53           0 : template<class T> void ImageHistory<T>::addHistory(
      54             :     const String& origin, const std::vector<String>& history
      55             : ) {
      56           0 :     auto lor = origin.empty()
      57             :         ? LogOrigin(getClass(), __func__)
      58             :                 : LogOrigin(origin);
      59           0 :     auto& log = _image->logger();
      60             :     //
      61             :     // Make sure we can write into the history table if needed
      62             :     //
      63           0 :     log.reopenRW();
      64           0 :     auto& sink = log.sink();
      65           0 :     for(const auto& line: history) {
      66           0 :         auto x = line;
      67           0 :         x.trim();
      68           0 :         if (! x.empty()) {
      69           0 :             LogMessage msg(line, lor);
      70           0 :             sink.postLocally(msg);
      71             :         }
      72             :     }
      73           0 : }
      74             : 
      75             : template<class T> void ImageHistory<T>::addHistory(
      76             :     const casacore::String& origin,
      77             :     const std::vector<string>& history
      78             : ) {
      79             :     std::vector<casacore::String> x;
      80             :     for( casacore::String h: history ) {
      81             :         x.push_back(h);
      82             :     }
      83             :     addHistory(origin, x);
      84             : }
      85             : 
      86             : template<class T> void ImageHistory<T>::addHistory(
      87             :     const casacore::LogOrigin& origin,
      88             :     const std::vector<casacore::String>& history
      89             : ) {
      90             :     addHistory(origin.toString(), history);
      91             : }
      92             : 
      93           9 : template<class T> void ImageHistory<T>::clear() {
      94           9 :     _image->logger().clear();
      95           9 : }
      96             : 
      97             : template <class T>
      98           0 : void ImageHistory<T>::addHistory(
      99             :     const std::vector<std::pair<casacore::String, casacore::String>>& history
     100             : ) {
     101           0 :     for (const auto& line: history) {
     102           0 :         addHistory(line.first, line.second);
     103             :     }
     104           0 : }
     105             : 
     106             : template<class T> casacore::LogIO& ImageHistory<T>::getLogSink() {
     107             :     return _image->logSink();
     108             : }
     109             : 
     110           0 : template<class T> std::vector<String> ImageHistory<T>::get(
     111             :     Bool list
     112             : ) const {
     113           0 :     std::vector<String> t;
     114           0 :     const LoggerHolder& logger = _image->logger();
     115           0 :     LogIO log;
     116           0 :     LogMessage msg;
     117           0 :     auto iter = logger.begin();
     118           0 :     for (; iter != logger.end(); ++iter) {
     119           0 :         auto msgString = iter->message();
     120           0 :         if (list) {
     121           0 :             auto lor = iter->location().empty()
     122             :                 ? LogOrigin(getClass(), __func__)
     123             :                 : LogOrigin(iter->location());
     124           0 :             msg.origin(lor);
     125           0 :             Double jdn = iter->time()/C::day + C::MJD0;
     126           0 :             Time mytime(jdn);
     127           0 :             msg.messageTime(mytime);
     128           0 :             msg.message(msgString, true);
     129           0 :             log.post(msg);
     130             :         }
     131           0 :         t.push_back(msgString);
     132             :     }
     133           0 :     return t;
     134             : }
     135             : 
     136             : template <class T> std::vector<std::pair<casacore::String, casacore::String>> 
     137             : ImageHistory<T>::getApplicationHistory(
     138             :     const casacore::LogOrigin& origin, const casacore::String& taskname,
     139             :     const vector<casacore::String>& paramNames, const vector<casac::variant>& paramValues,
     140             :     const casacore::String& imageName
     141             : ) {
     142             :     ThrowIf(
     143             :         paramNames.size() != paramValues.size(),
     144             :         "paramNames and paramValues must have the same number of elements"
     145             :     );
     146             :     std::pair<casacore::String, casacore::String> x;
     147             :     x.first = origin.fullName();
     148             :     x.second = "Ran " + taskname + " on " + imageName;
     149             :     std::vector<std::pair<casacore::String, casacore::String>> appHistory;
     150             :     appHistory.push_back(x);
     151             :     vector<std::pair<casacore::String, casac::variant>> inputs;
     152             :     vector<casacore::String>::const_iterator end = paramNames.end();
     153             :     auto begin = paramNames.cbegin();
     154             :     auto value = paramValues.cbegin();
     155             :     //auto end = paramNames.cend();
     156             :     casacore::String out = taskname + "(";
     157             :     casacore::String quote;
     158             :     // auto name = begin;
     159             :     for (auto name = begin; name != end; ++name, ++value) {
     160             :         if (name != begin) {
     161             :             out += ", ";
     162             :         }
     163             :         quote = value->type() == casac::variant::STRING ? "'" : "";
     164             :         out += *name + "=" + quote;
     165             :         out += value->toString();
     166             :         out += quote;
     167             :         /*
     168             :         name++;
     169             :         value++;
     170             :         */
     171             :     }
     172             :     x.second = out + ")";
     173             :     appHistory.push_back(x);
     174             :     return appHistory;
     175             : }
     176             : 
     177             : template<class T> vector<string> ImageHistory<T>::getAsStdStrings(
     178             :         casacore::Bool list
     179             : ) const {
     180             :     vector<casacore::String> hist = get(list);
     181             :     vector<string> x;
     182             :     for( casacore::String s: hist ) {
     183             :         x.push_back(s.c_str());
     184             :     }
     185             :     return x;
     186             : }
     187             : 
     188          18 : template<class T> template <class U>  void ImageHistory<T>::append(
     189             :     SPCIIU image
     190             : ) {
     191          18 :     _image->logger().append(image->logger());
     192          18 : }
     193             : 
     194           9 : template<class T> template <class U>  void ImageHistory<T>::append(
     195             :     SPIIU image
     196             : ) {
     197           9 :     append(std::const_pointer_cast<const casacore::ImageInterface<U>>(image));
     198             :     //_image->logger().append(image->logger());
     199           9 : }
     200             : 
     201             : }