File indexing completed on 2024-04-28 05:37:01

 /***************************************************************************
  * Copyright (C) 2014 by Renaud Guezennec                                   *
  * https://rolisteam.org/contact                      *
  *                                                                          *
  *  This file is part of DiceParser                                         *
  *                                                                          *
  * DiceParser 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 2 of the License, or        *
  * (at your option) any later version.                                      *
  *                                                                          *
  * This program 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 this program; if not, write to the                            *
  * Free Software Foundation, Inc.,                                          *
  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.                 *
  ***************************************************************************/
 #include "validator.h"
 
 Validator::Validator() {}
 Validator::~Validator() {}
 
 template <typename Functor>
 qint64 Validator::onEach(const std::vector<Die*>& b, bool recursive, bool unlight, Functor functor) const
 {
     qint64 result= 0;
     std::for_each(b.begin(), b.end(), [this, recursive, unlight, functor, &result](Die* die) {
         if(hasValid(die, recursive, unlight))
         {
             ++result;
             functor(die, recursive, unlight);
         }
     });
     return result;
 }
 
 template <typename Functor>
 qint64 Validator::onEachValue(const std::vector<Die*>& b, bool recursive, bool unlight, Functor functor) const
 {
     qint64 result= 0;
     std::for_each(b.begin(), b.end(), [this, recursive, unlight, functor, &result](Die* die) {
         if(hasValid(die, recursive, unlight))
         {
             ++result;
             functor(die, recursive, unlight);
         }
     });
     return result;
 }
 
 template <typename Functor>
 qint64 Validator::oneOfThem(const std::vector<Die*>& b, bool recursive, bool unlight, Functor functor) const
 {
     auto oneOfThem= std::any_of(b.begin(), b.end(),
                                 [this, recursive, unlight](Die* die) { return hasValid(die, recursive, unlight); });
     if(oneOfThem)
         functor(recursive, unlight);
     return oneOfThem ? 1 : 0;
 }
 
 template <typename Functor>
 qint64 Validator::allOfThem(const std::vector<Die*>& b, bool recursive, bool unlight, Functor functor) const
 {
     auto all= std::all_of(b.begin(), b.end(),
                           [this, recursive, unlight](Die* die) { return hasValid(die, recursive, unlight); });
     if(all)
         functor(recursive, unlight);
     return all ? 1 : 0;
 }
 
 template <typename Functor>
 qint64 Validator::onScalar(const std::vector<Die*>& b, bool recursive, bool unlight, Functor functor) const
 {
     qint64 result= 0;
     for(const auto& die : b)
     {
         result+= die->getValue();
     }
     Die die;
     die.setValue(result);
     if(hasValid(&die, recursive, unlight))
     {
         functor(recursive, unlight);
         return 1;
     }
     return 0;
 }
 
 const std::set<qint64>& Validator::getPossibleValues(const std::pair<qint64, qint64>&)
 {
     return m_values;
 }
 
 template <typename Functor>
 qint64 Validator::validResult(const std::vector<Die*>& b, bool recursive, bool unlight, Functor functor) const
 {
     qint64 result;
     switch(m_conditionType)
     {
     case Dice::OnEach:
         result= onEach(b, recursive, unlight, functor);
         break;
     case Dice::OnEachValue:
         result= onEachValue(b, recursive, unlight, functor);
         break;
     case Dice::OneOfThem:
         result= oneOfThem(b, recursive, unlight, functor);
         break;
     case Dice::AllOfThem:
         result= allOfThem(b, recursive, unlight, functor);
         break;
     case Dice::OnScalar:
         result= onScalar(b, recursive, unlight, functor);
         break;
     }
     return result;
 }
 
 Dice::ConditionType Validator::getConditionType() const
 {
     return m_conditionType;
 }
 
 void Validator::setConditionType(const Dice::ConditionType& conditionType)
 {
     m_conditionType= conditionType;
 }