nel/src/gui/interface_expr_node.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20
  21 #include "stdpch.h"
  22 #include "nel/misc/cdb_leaf.h"
  23 #include "nel/misc/cdb_branch.h"
  24 #include "nel/gui/interface_expr_node.h"
  25
  26 using NLMISC::ICDBNode;
  27 using NLMISC::CCDBNodeBranch;
  28 using NLMISC::CCDBNodeLeaf;
  29
  30 #ifdef DEBUG_NEW
  31 #define new DEBUG_NEW
  32 #endif
  33
  34 namespace NLGUI
  35 {
  36
  37         // *******************************************************************************************************
  38         void CInterfaceExprNodeValue::eval(CInterfaceExprValue &result)
  39         {
  40                 result = Value;
  41         }
  42
  43         void CInterfaceExprNodeValue::evalWithDepends(CInterfaceExprValue &result, std::vector<ICDBNode *> &/* nodes */)
  44         {
  45                 result = Value;
  46         }
  47
  48         void CInterfaceExprNodeValue::getDepends(std::vector<ICDBNode *> &/* nodes */)
  49         {
  50         }
  51
  52
  53         // *******************************************************************************************************
  54         void CInterfaceExprNodeValueFnCall::eval(CInterfaceExprValue &result)
  55         {
  56                 nlassert(Func);
  57                 uint numParams = (uint)Params.size();
  58                 std::vector<CInterfaceExprValue> params(numParams);
  59                 for(uint k = 0; k < numParams; ++k)
  60                 {
  61                         Params[k]->eval(params[k]);
  62                 }
  63                 Func(params, result); // do actual call
  64         }
  65
  66         void CInterfaceExprNodeValueFnCall::evalWithDepends(CInterfaceExprValue &result, std::vector<ICDBNode *> &nodes)
  67         {
  68                 nlassert(Func);
  69                 uint numParams = (uint)Params.size();
  70                 std::vector<CInterfaceExprValue> params(numParams);
  71                 for(uint k = 0; k < numParams; ++k)
  72                 {
  73                         Params[k]->evalWithDepends(params[k], nodes);
  74                 }
  75                 Func(params, result); // do actual call
  76         }
  77
  78         void CInterfaceExprNodeValueFnCall::getDepends(std::vector<ICDBNode *> &nodes)
  79         {
  80                 uint numParams = (uint)Params.size();
  81                 for(uint k = 0; k < numParams; ++k)
  82                 {
  83                         Params[k]->getDepends(nodes);
  84                 }
  85         }
  86
  87
  88         CInterfaceExprNodeValueFnCall::~CInterfaceExprNodeValueFnCall()
  89         {
  90                 for(uint k = 0; k < Params.size(); ++k)
  91                 {
  92                         delete Params[k];
  93                 }
  94         }
  95
  96         // *******************************************************************************************************
  97         void CInterfaceExprNodeDBLeaf::eval(CInterfaceExprValue &result)
  98         {
  99                 nlassert(Leaf);
 100                 result.setInteger(Leaf->getValue64());
 101         }
 102
 103         void CInterfaceExprNodeDBLeaf::evalWithDepends(CInterfaceExprValue &result,std::vector<ICDBNode *> &nodes)
 104         {
 105                 nlassert(Leaf);
 106                 result.setInteger(Leaf->getValue64());
 107                 if (std::find(nodes.begin(), nodes.end(), Leaf) == nodes.end())
 108                 {
 109                         nodes.push_back(Leaf);
 110                 }
 111         }
 112
 113         void CInterfaceExprNodeDBLeaf::getDepends(std::vector<ICDBNode *> &nodes)
 114         {
 115                 nlassert(Leaf);
 116                 if (std::find(nodes.begin(), nodes.end(), Leaf) == nodes.end())
 117                 {
 118                         nodes.push_back(Leaf);
 119                 }
 120         }
 121
 122
 123         // *******************************************************************************************************
 124         void CInterfaceExprNodeDBBranch::eval(CInterfaceExprValue &result)
 125         {
 126                 nlassert(Branch);
 127                 result.setInteger(0);
 128         }
 129
 130         void CInterfaceExprNodeDBBranch::evalWithDepends(CInterfaceExprValue &result,std::vector<ICDBNode *> &nodes)
 131         {
 132                 nlassert(Branch);
 133                 result.setInteger(0);
 134                 if (std::find(nodes.begin(), nodes.end(), Branch) == nodes.end())
 135                 {
 136                         nodes.push_back(Branch);
 137                 }
 138         }
 139
 140         void CInterfaceExprNodeDBBranch::getDepends(std::vector<ICDBNode *> &nodes)
 141         {
 142                 nlassert(Branch);
 143                 if (std::find(nodes.begin(), nodes.end(), Branch) == nodes.end())
 144                 {
 145                         nodes.push_back(Branch);
 146                 }
 147         }
 148
 149
 150         // *******************************************************************************************************
 151         void CInterfaceExprNodeDependantDBRead::eval(CInterfaceExprValue &result)
 152         {
 153                 // no gain there, but barely used
 154                 CInterfaceExpr::eval(Expr, result);
 155         }
 156
 157         void CInterfaceExprNodeDependantDBRead::evalWithDepends(CInterfaceExprValue &result, std::vector<ICDBNode *> &nodes)
 158         {
 159                 CInterfaceExpr::eval(Expr, result, &nodes);
 160         }
 161
 162         void CInterfaceExprNodeDependantDBRead::getDepends(std::vector<ICDBNode *> &nodes)
 163         {
 164                 CInterfaceExprValue dummyResult;
 165                 CInterfaceExpr::eval(Expr, dummyResult, &nodes, true);
 166         }
 167
 168 }
 169