Teuchos_VerboseObject.hpp

// @HEADER
// *****************************************************************************
//                    Teuchos: Common Tools Package
//
// Copyright 2004 NTESS and the Teuchos contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef TEUCHOS_VERBOSE_OBJECT_HPP
#define TEUCHOS_VERBOSE_OBJECT_HPP
 
#include "Teuchos_RCP.hpp"
#include "Teuchos_FancyOStream.hpp"
#include "Teuchos_VerbosityLevel.hpp"
 
 
namespace Teuchos {
 
 
class TEUCHOSCORE_LIB_DLL_EXPORT VerboseObjectBase {
public:
 
 
 
  static void setDefaultOStream( const RCP<FancyOStream> &defaultOStream );
 
  static RCP<FancyOStream> getDefaultOStream();
 
 
 
 
  virtual ~VerboseObjectBase();
 
  explicit
  VerboseObjectBase(
    const RCP<FancyOStream> &oStream = Teuchos::null
    );
 
  virtual const VerboseObjectBase& setOStream(
    const RCP<FancyOStream> &oStream) const;
 
  virtual const VerboseObjectBase& setOverridingOStream(
    const RCP<FancyOStream> &oStream) const;
 
  virtual VerboseObjectBase& setLinePrefix(const std::string &linePrefix);
 
 
 
 
  virtual RCP<FancyOStream> getOStream() const;
 
  virtual RCP<FancyOStream> getOverridingOStream() const;
 
  virtual std::string getLinePrefix() const;
 
 
 
 
  virtual OSTab getOSTab(const int tabs = 1, const std::string &linePrefix = "") const;
 
 
protected:
 
  void initializeVerboseObjectBase(
    const RCP<FancyOStream> &oStream = Teuchos::null
    );
 
  virtual void informUpdatedVerbosityState() const;
 
private:
 
  std::string thisLinePrefix_;
 
//use pragmas to disable some false-positive warnings for windows sharedlibs export
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4251)
#endif
  mutable RCP<FancyOStream> thisOStream_;
  mutable RCP<FancyOStream> thisOverridingOStream_;
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
  static RCP<FancyOStream>& privateDefaultOStream();
 
};
 
 
template<class ObjectType>
class VerboseObject : virtual public VerboseObjectBase {
public:
 
 
  static void setDefaultVerbLevel( const EVerbosityLevel defaultVerbLevel);
 
  static EVerbosityLevel getDefaultVerbLevel();
 
 
 
  explicit
  VerboseObject(
    const EVerbosityLevel verbLevel = VERB_DEFAULT,  // Note, this must be the same as the default value for defaultVerbLevel_
    const RCP<FancyOStream> &oStream  = Teuchos::null
    );
 
  virtual const VerboseObject& setVerbLevel(
    const EVerbosityLevel verbLevel) const;
 
  virtual const VerboseObject& setOverridingVerbLevel(
    const EVerbosityLevel verbLevel) const;
 
 
 
  virtual EVerbosityLevel getVerbLevel() const;
 
 
protected:
 
  void initializeVerboseObject(
    const EVerbosityLevel verbLevel = VERB_DEFAULT,
    const RCP<FancyOStream> &oStream  = Teuchos::null
    );
 
private:
 
  mutable EVerbosityLevel thisVerbLevel_;
  mutable EVerbosityLevel thisOverridingVerbLevel_;
 
  static EVerbosityLevel& privateDefaultVerbLevel();
 
};
 
 
template<class ObjectType>
class VerboseObjectTempState {
public:
  VerboseObjectTempState(
    const RCP<const VerboseObject<ObjectType> > &verboseObject,
    const RCP<FancyOStream> &newOStream,
    const EVerbosityLevel newVerbLevel
    ):
    verboseObject_(verboseObject),
    oldVerbLevel_(VERB_DEFAULT)
    {
      if(verboseObject_.get()) {
        oldOStream_ = verboseObject_->getOStream();
        oldVerbLevel_ = verboseObject_->getVerbLevel();
        verboseObject_->setOStream(newOStream);
        verboseObject_->setVerbLevel(newVerbLevel);
      }
    }
  ~VerboseObjectTempState()
    {
      if(verboseObject_.get()) {
        verboseObject_->setOStream(oldOStream_);
        verboseObject_->setVerbLevel(oldVerbLevel_);
      }
    }
private:
  RCP<const VerboseObject<ObjectType> > verboseObject_;
  RCP<FancyOStream> oldOStream_;
  EVerbosityLevel oldVerbLevel_;
  // Not defined and not to be called
  VerboseObjectTempState();
  VerboseObjectTempState(const VerboseObjectTempState&);
  VerboseObjectTempState& operator=(const VerboseObjectTempState&);
};
 
 
// //////////////////////////////////
// Template defintions
 
 
//
// VerboseObject
//
 
 
// Public static member functions
 
 
template<class ObjectType>
void VerboseObject<ObjectType>::setDefaultVerbLevel( const EVerbosityLevel defaultVerbLevel)
{
  privateDefaultVerbLevel() = defaultVerbLevel;
}
 
 
template<class ObjectType>
EVerbosityLevel VerboseObject<ObjectType>::getDefaultVerbLevel()
{
  return privateDefaultVerbLevel();
}
 
 
// Constructors/Initializers
 
 
template<class ObjectType>
VerboseObject<ObjectType>::VerboseObject(
  const EVerbosityLevel verbLevel,
  const RCP<FancyOStream> &oStream
  )
  : thisOverridingVerbLevel_(VERB_DEFAULT)
{
  this->initializeVerboseObject(verbLevel,oStream);
}
 
 
template<class ObjectType>
void VerboseObject<ObjectType>::initializeVerboseObject(
  const EVerbosityLevel verbLevel,
  const RCP<FancyOStream> &oStream
  )
{
  thisVerbLevel_ = verbLevel;
  this->initializeVerboseObjectBase(oStream);
}
 
 
template<class ObjectType>
const VerboseObject<ObjectType>&
VerboseObject<ObjectType>::setVerbLevel(const EVerbosityLevel verbLevel) const
{
  thisVerbLevel_ = verbLevel;
  informUpdatedVerbosityState();
  return *this;
}
 
 
template<class ObjectType>
const VerboseObject<ObjectType>&
VerboseObject<ObjectType>::setOverridingVerbLevel(
  const EVerbosityLevel verbLevel
  ) const
{
  thisOverridingVerbLevel_ = verbLevel;
  informUpdatedVerbosityState();
  return *this;
}
 
 
// Query functions
 
 
template<class ObjectType>
EVerbosityLevel VerboseObject<ObjectType>::getVerbLevel() const
{
  if (VERB_DEFAULT != thisOverridingVerbLevel_)
    return thisOverridingVerbLevel_;
  if (VERB_DEFAULT == thisVerbLevel_)
    return getDefaultVerbLevel();
  return thisVerbLevel_;
}
 
 
// Private static members
 
 
template<class ObjectType>
EVerbosityLevel& VerboseObject<ObjectType>::privateDefaultVerbLevel()
{
  static EVerbosityLevel defaultVerbLevel = VERB_DEFAULT;
  return defaultVerbLevel;
}
 
 
} // namespace Teuchos
 
 
#endif // TEUCHOS_VERBOSE_OBJECT_HPP