nel/tools/logic/logic_editor_dll/Condition.cpp

   1 // Condition.cpp: implementation of the CCondition class.
   2 //
   3 //////////////////////////////////////////////////////////////////////
   4
   5 #include "stdafx.h"
   6 #include "logic_editor.h"
   7 #include "condition.h"
   8 #include "nel/logic/logic_condition.h"
   9
  10 #include <vector>
  11
  12 #ifdef _DEBUG
  13 #undef THIS_FILE
  14 static char THIS_FILE[]=__FILE__;
  15 #define new DEBUG_NEW
  16 #endif
  17
  18 using namespace std;
  19 using namespace NLLOGIC;
  20
  21 //////////////////////////////////////////////////////////////////////
  22 // CConditionNode implementation
  23 //////////////////////////////////////////////////////////////////////
  24
  25 CConditionNode::CConditionNode(const CConditionNode &node)
  26 {
  27         this->m_dComparand = node.m_dComparand;
  28         this->m_pParentNode = node.m_pParentNode;
  29         this->m_sConditionName = node.m_sConditionName;
  30         this->m_sOperator = node.m_sOperator;
  31         this->m_sVariableName = node.m_sVariableName;
  32         this->m_type = node.m_type;
  33
  34         // copy sub condition node tree
  35         CConditionNode *pNode, *newNode;
  36         POSITION pos = node.m_ctSubTree.GetHeadPosition();
  37         while (pos != NULL)
  38         {
  39                 pNode = m_ctSubTree.GetNext( pos );
  40
  41                 if (pNode != NULL)
  42                 {
  43                         newNode = new CConditionNode( *pNode );
  44                         this->m_ctSubTree.AddTail( newNode );
  45                         newNode->m_pParentNode = this;
  46                 }
  47         }
  48
  49 }
  50
  51
  52
  53 CConditionNode::~CConditionNode()
  54 {
  55         CConditionNode *pNode = NULL;
  56
  57         // delete all sub nodes
  58         POSITION pos = m_ctSubTree.GetHeadPosition();
  59         while (pos != NULL)
  60         {
  61                 pNode = m_ctSubTree.GetNext( pos );
  62
  63                 if (pNode != NULL)
  64                 {
  65                         delete pNode;
  66                         pNode = NULL;
  67                 }
  68         }
  69 }
  70
  71 const CString & CConditionNode::getNodeAsString() const
  72 {
  73         m_sNodeString.Empty();
  74
  75         if (m_type == NOT)
  76                 m_sNodeString = "NOT";
  77         else if (m_type == TERMINATOR)
  78                 m_sNodeString = "term";
  79         else if (m_type == SUB_CONDITION)
  80                 m_sNodeString = m_sConditionName;
  81         else // comparison
  82         {
  83                 m_sNodeString.Format(_T("%s %s %g"),LPCTSTR(m_sVariableName),LPCTSTR(m_sOperator), m_dComparand );
  84         }
  85
  86         return m_sNodeString;
  87 }
  88
  89
  90
  91 void CConditionNode::changeConditionName( const CString &old, const CString &newName)
  92 {
  93         CConditionNode *pNode = NULL;
  94
  95         POSITION pos = m_ctSubTree.GetHeadPosition();
  96         while (pos != NULL)
  97         {
  98                 pNode = m_ctSubTree.GetNext( pos );
  99
 100                 if (pNode != NULL)
 101                 {
 102                         pNode->changeConditionName(old, newName);
 103                 }
 104         }
 105
 106         //
 107         if ( m_sConditionName == old)
 108                 m_sConditionName = newName;
 109 }
 110
 111 void CConditionNode::conditionDeleted( const CString &name)
 112 {
 113         CConditionNode *pNode = NULL;
 114
 115         POSITION oldpos;
 116         POSITION pos = m_ctSubTree.GetHeadPosition();
 117         while (pos != NULL)
 118         {
 119                 oldpos = pos;
 120                 pNode = m_ctSubTree.GetNext( pos );
 121
 122                 if (pNode != NULL)
 123                 {
 124                         if ( pNode->m_sConditionName != name)
 125                                 pNode->conditionDeleted(name);
 126                         else
 127                         {
 128                                 this->m_ctSubTree.RemoveAt( oldpos );
 129                                 delete pNode;
 130                                 pNode = NULL;
 131                         }
 132                 }
 133         }
 134 }
 135
 136
 137
 138
 139
 140 //////////////////////////////////////////////////////////////////////
 141 // CCondition implementation
 142 //////////////////////////////////////////////////////////////////////
 143 CCondition::CCondition()
 144 {
 145 }
 146
 147
 148 CCondition::CCondition( const CCondition &cond)
 149 {
 150         this->m_sName = cond.m_sName;
 151
 152         // copy sub condition node tree
 153         CConditionNode *pNode, *newNode;
 154         POSITION pos = cond.m_ctConditionTree.GetHeadPosition();
 155         while (pos != NULL)
 156         {
 157                 pNode = m_ctConditionTree.GetNext( pos );
 158
 159                 if (pNode != NULL)
 160                 {
 161                         newNode = new CConditionNode( *pNode );
 162                         this->m_ctConditionTree.AddTail( newNode );
 163                 }
 164         }
 165
 166 }
 167
 168
 169 CCondition::~CCondition()
 170 {
 171         CConditionNode *pNode = NULL;
 172
 173         // delete all sub nodes
 174         POSITION pos = m_ctConditionTree.GetHeadPosition();
 175         while (pos != NULL)
 176         {
 177                 pNode = m_ctConditionTree.GetNext( pos );
 178
 179                 if (pNode != NULL)
 180                 {
 181                         delete pNode;
 182                         pNode = NULL;
 183                 }
 184         }
 185 }
 186
 187
 188
 189 void CCondition::changeConditionName( CString old, const CString &newName) const
 190 {
 191         CConditionNode *pNode = NULL;
 192
 193         POSITION pos = m_ctConditionTree.GetHeadPosition();
 194         while (pos != NULL)
 195         {
 196                 pNode = m_ctConditionTree.GetNext( pos );
 197
 198                 if (pNode != NULL)
 199                 {
 200                         pNode->changeConditionName( old, newName);
 201                 }
 202         }
 203 }
 204
 205
 206 void CCondition::conditionDeleted( CString name)
 207 {
 208         CConditionNode *pNode = NULL;
 209
 210         POSITION oldpos;
 211         POSITION pos = m_ctConditionTree.GetHeadPosition();
 212         while (pos != NULL)
 213         {
 214                 oldpos = pos;
 215                 pNode = m_ctConditionTree.GetNext( pos );
 216
 217                 if (pNode != NULL)
 218                 {
 219                         if ( pNode->m_sConditionName != name)
 220                                 pNode->conditionDeleted(name);
 221                         else
 222                         {
 223                                 this->m_ctConditionTree.RemoveAt( oldpos );
 224                                 delete pNode;
 225                                 pNode = NULL;
 226                         }
 227                 }
 228         }
 229 }
 230
 231
 232
 233 //-----------------------------------------------------
 234 //      cConditionNodeToCLogicConditionNode (Editor --> Service)
 235 //
 236 //-----------------------------------------------------
 237 void cConditionNodeToCLogicConditionNode(CConditionNode * conditionNode, CLogicConditionNode * logicConditionNode )
 238 {
 239         // if this node is a terminator node
 240         if( conditionNode->m_type == CConditionNode::TERMINATOR )
 241         {
 242                 logicConditionNode->Type = CLogicConditionNode::TERMINATOR;
 243         }
 244         else
 245         // this node is a logic node
 246         {
 247                 logicConditionNode->Type = CLogicConditionNode::LOGIC_NODE;
 248
 249                 // part 1 : a logic block(not/comparison/subcondition)
 250                 switch( conditionNode->m_type )
 251                 {
 252                         case CConditionNode::NOT :
 253                         {
 254                                 logicConditionNode->LogicBlock.Type = CLogicConditionLogicBlock::NOT;
 255
 256                         }
 257                         break;
 258
 259                         case CConditionNode::COMPARISON :
 260                         {
 261                                 logicConditionNode->LogicBlock.Type = CLogicConditionLogicBlock::COMPARISON;
 262
 263                                 logicConditionNode->LogicBlock.ComparisonBlock.VariableName = NLMISC::tStrToUtf8(conditionNode->m_sVariableName);
 264                             logicConditionNode->LogicBlock.ComparisonBlock.Operator = NLMISC::tStrToUtf8(conditionNode->m_sOperator);
 265                                 logicConditionNode->LogicBlock.ComparisonBlock.Comparand = (sint64)conditionNode->m_dComparand;
 266                         }
 267                         break;
 268
 269                         case CConditionNode::SUB_CONDITION :
 270                         {
 271                                 logicConditionNode->LogicBlock.Type = CLogicConditionLogicBlock::SUB_CONDITION;
 272
 273                                 logicConditionNode->LogicBlock.SubCondition = NLMISC::tStrToUtf8(conditionNode->m_sConditionName);
 274                         }
 275                         break;
 276                 }
 277
 278                 // part 2 : a condition sub tree
 279                 POSITION pos;
 280                 for( pos = conditionNode->m_ctSubTree.GetHeadPosition(); pos != NULL; )
 281                 {
 282                         CConditionNode * pConditionNode = conditionNode->m_ctSubTree.GetNext( pos );
 283                         CLogicConditionNode * logicConditionNodeTmp = new CLogicConditionNode();
 284                         cConditionNodeToCLogicConditionNode( pConditionNode, logicConditionNodeTmp );
 285                         logicConditionNode->addNode( logicConditionNodeTmp );
 286                 }
 287         }
 288
 289 } // cConditionNodeToCLogicConditionNode //
 290
 291
 292
 293
 294 //-----------------------------------------------------
 295 //      cConditionToCLogicCondition (Editor --> Service)
 296 //
 297 //-----------------------------------------------------
 298 void cConditionToCLogicCondition( CCondition& condition, CLogicCondition& logicCondition )
 299 {
 300         // condition name
 301         logicCondition.setName(NLMISC::tStrToUtf8(condition.m_sName));
 302
 303         // nodes
 304         POSITION pos;
 305         for( pos = condition.m_ctConditionTree.GetHeadPosition(); pos != NULL; )
 306         {
 307                 // get the node
 308                 CConditionNode * pConditionNode = condition.m_ctConditionTree.GetNext( pos );
 309
 310                 // convert the node
 311                 CLogicConditionNode * logicConditionNode = new CLogicConditionNode();
 312                 cConditionNodeToCLogicConditionNode( pConditionNode, logicConditionNode );
 313
 314                 // add the node
 315                 logicCondition.addNode( *logicConditionNode );
 316         }
 317
 318 } // cConditionToCLogicCondition //
 319
 320
 321
 322
 323
 324
 325 //-----------------------------------------------------
 326 //      cLogicConditionNodeToCConditionNode (Service --> Editor)
 327 //
 328 //-----------------------------------------------------
 329 void cLogicConditionNodeToCConditionNode( const CLogicConditionNode * logicConditionNode, CConditionNode * node )
 330 {
 331         // terminator node
 332         if(logicConditionNode->Type == CLogicConditionNode::TERMINATOR)
 333         {
 334                 node->m_type = CConditionNode::TERMINATOR;
 335         }
 336         // logic block with condition sub tree
 337         else
 338         {
 339                 // part 1 : a logic block(not/comparison/subcondition)
 340                 switch( logicConditionNode->LogicBlock.Type )
 341                 {
 342                         case CLogicConditionLogicBlock::NOT :
 343                         {
 344                                 node->m_type = CConditionNode::NOT;
 345                         };
 346                         break;
 347
 348                         case CLogicConditionLogicBlock::COMPARISON :
 349                         {
 350                                 node->m_type = CConditionNode::COMPARISON;
 351
 352                                 node->m_sVariableName = CString(logicConditionNode->LogicBlock.ComparisonBlock.VariableName.c_str());
 353                                 node->m_sOperator = CString(logicConditionNode->LogicBlock.ComparisonBlock.Operator.c_str());
 354                                 node->m_dComparand = (double)logicConditionNode->LogicBlock.ComparisonBlock.Comparand;
 355
 356                         };
 357                         break;
 358
 359                         case CLogicConditionLogicBlock::SUB_CONDITION :
 360                         {
 361                                 node->m_type = CConditionNode::SUB_CONDITION;
 362                                 node->m_sConditionName = CString(logicConditionNode->LogicBlock.SubCondition.c_str());
 363                         };
 364                         break;
 365
 366                         default :
 367                         {
 368                                 node->m_type = CConditionNode::TERMINATOR;
 369                         }
 370
 371                 }
 372
 373                 // part 2 : a condition sub tree
 374                 vector<CLogicConditionNode *>::const_iterator itNode;
 375                 for( itNode = logicConditionNode->_Nodes.begin(); itNode != logicConditionNode->_Nodes.end(); ++itNode )
 376                 {
 377                         CConditionNode * nodeTmp = new CConditionNode();
 378                         cLogicConditionNodeToCConditionNode( *itNode, nodeTmp );
 379                         nodeTmp->m_pParentNode = node;
 380                         node->m_ctSubTree.AddTail( nodeTmp );
 381                 }
 382
 383         }
 384
 385 } // cLogicConditionNodeToCConditionNode //
 386
 387
 388
 389
 390 //-----------------------------------------------
 391 //      cLogicConditionToCCondition
 392 //
 393 //-----------------------------------------------
 394 void cLogicConditionToCCondition( const CLogicCondition& logicCondition, CCondition& condition )
 395 {
 396         // condition name
 397         condition.m_sName = CString( logicCondition.getName().c_str() );
 398
 399         // condition tree
 400         vector<CLogicConditionNode>::const_iterator itNode;
 401         for( itNode = logicCondition.Nodes.begin(); itNode != logicCondition.Nodes.end(); ++itNode )
 402         {
 403                 // convert the node
 404                 CConditionNode * node = new CConditionNode();
 405                 cLogicConditionNodeToCConditionNode( &(*itNode), node );
 406
 407                 // add the node
 408                 condition.m_ctConditionTree.AddTail( node );
 409         }
 410
 411 } // cLogicConditionToCCondition //
 412
 413