Common/Util/Validate.h

Go to the documentation of this file.

//-------------------------------------------------------------------
//  Copyright (c) 2004 Evan Sherbrooke and Michael Lauer
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
//-------------------------------------------------------------------
#pragma once

#ifndef VOLUMILL_VALIDATE_H
#define VOLUMILL_VALIDATE_H

//
// A validate mechanism, a la Alexandrescu's Enforce
//

#include <string>
#include <sstream>
#include <stdexcept>

namespace util
{

class EnforcementHandlerInterface
{
public:
   enum { Warning=0, Error, Info };
   virtual ~EnforcementHandlerInterface();
   virtual void post (const std::string& message, const char* locus, int line, int level) = 0;
   static boost::shared_ptr<EnforcementHandlerInterface> getInstance();
   static void setInstance(boost::shared_ptr<EnforcementHandlerInterface> pEHI);
private:
   static boost::shared_ptr<EnforcementHandlerInterface> m_pEHI;
};

struct DefaultPredicate
{
  template <class T>
  static bool Wrong(const T& obj)
  {
    return !obj;
  }
};

struct DefaultRaiser
{
   template <class T>
   static void Throw(const T&, const std::string& message, const char* locus, int line)
   {
      boost::shared_ptr<EnforcementHandlerInterface> pEHI = EnforcementHandlerInterface::getInstance();
      if (pEHI)
      {
         pEHI->post (message, locus, line, EnforcementHandlerInterface::Error);
      }
      throw std::runtime_error(message);
   }
};

struct WarnRaiser
{
   template<class T>
   static void Throw(const T&, const std::string& message, const char* locus, int line)
   {
      boost::shared_ptr<EnforcementHandlerInterface> pEHI = EnforcementHandlerInterface::getInstance();
      if (pEHI)
      {
         pEHI->post (message, locus, line, EnforcementHandlerInterface::Warning);
      }
   }
};

struct InfoRaiser
{
   template<class T>
   static void Throw(const T&, const std::string& message, const char* locus, int line)
   {
      boost::shared_ptr<EnforcementHandlerInterface> pEHI = EnforcementHandlerInterface::getInstance();
      if (pEHI)
      {
         pEHI->post (message, locus, line, EnforcementHandlerInterface::Info);
      }
   }
};

template<typename Ref, typename P, typename R>
class Enforcer
{
public:
    Enforcer(Ref t, const char* locus, int line) : t_(t), locus_(P::Wrong(t) ? locus : 0), line_ (line)
    {
    }

    Ref operator*() const
    {
        if (locus_) R::Throw(t_, msg_, locus_, line_);
        return t_;
    }

    template <class MsgType>
    Enforcer& operator()(const MsgType& msg)
    {
        if (locus_) 
        {
            // Here we have time; an exception will be thrown
            std::ostringstream ss;
            ss << msg;
            msg_ += ss.str();
        }
        return *this;
    }

private:
    Ref t_;
    std::string msg_;
    const char* const locus_;
    int line_;
};

template <class P, class R, typename T>
inline Enforcer<const T&, P, R> 
MakeEnforcer(const T& t, const char* locus, int line)
{
    return Enforcer<const T&, P, R>(t, locus, line);
}

template <class P, class R, typename T>
inline Enforcer<T&, P, R> 
MakeEnforcer(T& t, const char* locus, int line)
{
    return Enforcer<T&, P, R>(t, locus, line);
}
}

#define VALIDATE(exp) \
   *::util::MakeEnforcer<util::DefaultPredicate, util::DefaultRaiser>((exp), "Expression '" #exp "' failed in '" \
    __FILE__ ,  __LINE__)

#define VALIDATE_ARG(exp) \
   *::util::MakeEnforcer<util::DefaultPredicate, util::DefaultRaiser>((exp), "Expression '" #exp "' failed in '" \
    __FILE__ , __LINE__)

#define WARN(exp) \
   *::util::MakeEnforcer<util::DefaultPredicate, util::WarnRaiser>((exp), "Expression '" #exp "' failed in '" \
    __FILE__ , __LINE__)

#define INFO(exp) \
   *::util::MakeEnforcer<util::DefaultPredicate, util::InfoRaiser>((0), "Message in '" __FILE__ , __LINE__)((exp))

#endif

---