AppState.h

Go to the documentation of this file.

// # AppState.h: casacore library configuration without environment variabes
// # Copyright (C) 2017
// # Associated Universities, Inc. Washington DC, USA.
// #
// # This library is free software; you can redistribute it and/or modify it
// # under the terms of the GNU Library General Public License as published by
// # the Free Software Foundation; either version 2 of the License, or (at your
// # option) any later version.
// #
// # This library 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 Library General Public
// # License for more details.
// #
// # You should have received a copy of the GNU Library General Public License
// # along with this library; if not, write to the Free Software Foundation,
// # Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
// #
// # Correspondence concerning AIPS++ should be addressed as follows:
// #        Internet email: casa-feedback@nrao.edu.
// #        Postal address: AIPS++ Project Office
// #                        National Radio Astronomy Observatory
// #                        520 Edgemont Road
// #                        Charlottesville, VA 22903-2475 USA
 
#ifndef CASA_APPSTATE_H
#define CASA_APPSTATE_H
 
#include <casacore/casa/aips.h>
 
#include <string>
#include <list>
#include <mutex>
 
namespace casacore {
 
// <summary>
// Base class for application state
// </summary>
 
// <use visibility=export>
 
// <reviewed reviewer="" date="yyyy/mm/dd" tests="" demos="">
// </reviewed>
 
// <synopsis>
// This class is the base class for casacore state. Its purpose is to
// allow applications initialize casacore's state without resorting to
// environment variables. This is done by creating an object whose
// class is derived from this base class, and then initializing the
// AppStateSource with the newly created object. After initialization,
// the AppStateSource takes ownership of the object. Please see the
// documentation for AppStateSource for more information.
// </synopsis>
 
class AppState {
 public:
  // use the data path to find the filename...
  virtual std::string resolve(const std::string &filename) const;
 
  // get the list of directories in the data path...
  virtual std::list<std::string> dataPath() const {
    static std::list<std::string> result;
    return result;
  }
 
  // Get AppState specified directory for (IERS) measures data.
  //
  // If data is not found in the specified directory and the
  // specified directiory name is nonempty (size > 0), an
  // exception will be thrown in findTab.
  virtual std::string measuresDir() const {
    static std::string result;
    return result;
  }
 
  virtual bool initialized() const { return false; }
 
  virtual ~AppState() {}
};
 
// <summary>
// Allow configuration of casacore without environment variables
// </summary>
 
// <use visibility=export>
 
// <reviewed reviewer="" date="yyyy/mm/dd" tests="" demos="">
// </reviewed>
 
// <synopsis>
// This class allows packages which use casacore to configure casacore
// behavior without reverting to environment variables. It is composed
// primarly of static functions. An external application configures
// casacore by calling the initialize(...) member function passing in
// a pointer to an object which is derived from the AppState base class.
// AppStateSource takes ownership of the provided pointer.
//
// When casacore no longer depends on compilers whose standard is older
// than C++11, the raw pointers here should be changed to
// unique_ptrs. The std::unique_ptr constructor is a constexpr, and it
// does not throw exceptions.
// </synopsis>
 
// <example>
// class MyState: public casacore::AppState {
//     public:
//         MyState( ) { }
//
//         const std::list<std::string> &dataPath( ) const {
//             static std::list<std::string> my_path;
//             return my_path;
//         }
//
//         bool initialized( ) const { return true; }
// };
//
// MyState &get_my_state( ) {
//     if ( AppStateSource::fetch( ).initialized( ) == false )
//         casacore::AppStateSource::initialize( new MyState );
//     return dynamic_cast<MyState&>(AppStateSource::fetch( ));
// }
//
// int main( int argc, char *argv[] ) {
//     MyState &state = get_my_state( );
//     ...
//     return 0;
// }
// </example>
class AppStateSource {
 public:
  static void initialize(AppState *init) {
    static std::mutex mutex_p;
    std::lock_guard<std::mutex> lock(mutex_p);
    if (user_state) delete user_state;
    user_state = init;
  }
  static AppState &fetch() {
    static AppState default_result;
    return user_state ? *user_state : default_result;
  }
 
 private:
  static AppState *user_state;
  AppStateSource() {}
  AppStateSource(AppStateSource const &) {}  // prevent copying
  void operator=(AppStateSource const &) {}  // prevent assignment
};
 
}  // namespace casacore
 
#endif