BVB Source Codes

CRYENGINE Show FlowStringNodes.cpp Source code

Return Download CRYENGINE: download FlowStringNodes.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   FlowStringNodes.cpp
  5. //  Version:     v1.00
  6. //  Created:     4/10/2006 by AlexL.
  7. //  Compilers:   Visual Studio.NET 2003
  8. //  Description:
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13.  
  14. #include "StdAfx.h"
  15.  
  16. #include <CryFlowGraph/IFlowBaseNode.h>
  17. #include <CryString/StringUtils.h>
  18.  
  19. //////////////////////////////////////////////////////////////////////////
  20. // String nodes.
  21. //////////////////////////////////////////////////////////////////////////
  22. //////////////////////////////////////////////////////////////////////////
  23. class CFlowNode_CompareStrings : public CFlowBaseNode<eNCT_Singleton>
  24. {
  25. public:
  26.         CFlowNode_CompareStrings(SActivationInfo* pActInfo) {};
  27.  
  28.         virtual void GetConfiguration(SFlowNodeConfig& config)
  29.         {
  30.                 static const SInputPortConfig in_config[] = {
  31.                         InputPortConfig_Void("Compare",     _HELP("Trigger to compare strings [A] and [B]")),
  32.                         InputPortConfig<string>("A",        _HELP("String A to compare")),
  33.                         InputPortConfig<string>("B",        _HELP("String B to compare")),
  34.                         InputPortConfig<bool>("IgnoreCase", true),
  35.                         { 0 }
  36.                 };
  37.                 static const SOutputPortConfig out_config[] = {
  38.                         OutputPortConfig<int>("Result", _HELP("Outputs -1 if A < B, 0 if A == B, 1 if A > B")),
  39.                         OutputPortConfig_Void("False",  _HELP("Triggered if A != B")),
  40.                         OutputPortConfig_Void("True",   _HELP("Triggered if A == B")),
  41.                         { 0 }
  42.                 };
  43.                 config.sDescription = _HELP("Compare two strings");
  44.                 config.pInputPorts = in_config;
  45.                 config.pOutputPorts = out_config;
  46.                 config.SetCategory(EFLN_APPROVED);
  47.         }
  48.         virtual void ProcessEvent(EFlowEvent evt, SActivationInfo* pActInfo)
  49.         {
  50.                 switch (evt)
  51.                 {
  52.                 case eFE_Activate:
  53.                         if (IsPortActive(pActInfo, 0))
  54.                         {
  55.                                 const string& a = GetPortString(pActInfo, 1);
  56.                                 const string& b = GetPortString(pActInfo, 2);
  57.                                 const bool bIgnoreCase = GetPortBool(pActInfo, 3);
  58.                                 const int result = bIgnoreCase ? stricmp(a.c_str(), b.c_str()) : a.compare(b);
  59.                                 ActivateOutput(pActInfo, 0, result);
  60.                                 ActivateOutput(pActInfo, result != 0 ? 1 : 2, 0);
  61.                         }
  62.                         break;
  63.                 }
  64.         };
  65.  
  66.         virtual void GetMemoryUsage(ICrySizer* s) const
  67.         {
  68.                 s->Add(*this);
  69.         }
  70. };
  71.  
  72. //////////////////////////////////////////////////////////////////////////
  73. class CFlowNode_SetString : public CFlowBaseNode<eNCT_Singleton>
  74. {
  75. public:
  76.         CFlowNode_SetString(SActivationInfo* pActInfo) {};
  77.  
  78.         virtual void GetConfiguration(SFlowNodeConfig& config)
  79.         {
  80.                 static const SInputPortConfig in_config[] = {
  81.                         InputPortConfig_Void("Set",   _HELP("Send string [In] to [Out]")),
  82.                         InputPortConfig<string>("In", _HELP("String to be set on [Out].\nWill also be set in Initialize")),
  83.                         { 0 }
  84.                 };
  85.                 static const SOutputPortConfig out_config[] = {
  86.                         OutputPortConfig<string>("Out"),
  87.                         { 0 }
  88.                 };
  89.                 config.sDescription = _HELP("Set String Value");
  90.                 config.pInputPorts = in_config;
  91.                 config.pOutputPorts = out_config;
  92.                 config.SetCategory(EFLN_APPROVED);
  93.         }
  94.         virtual void ProcessEvent(EFlowEvent evt, SActivationInfo* pActInfo)
  95.         {
  96.                 switch (evt)
  97.                 {
  98.                 case eFE_Activate:
  99.                 case eFE_Initialize:
  100.                         if (IsPortActive(pActInfo, 0))
  101.                         {
  102.                                 ActivateOutput(pActInfo, 0, GetPortString(pActInfo, 1));
  103.                         }
  104.                         break;
  105.                 }
  106.         };
  107.  
  108.         virtual void GetMemoryUsage(ICrySizer* s) const
  109.         {
  110.                 s->Add(*this);
  111.         }
  112. };
  113.  
  114. //////////////////////////////////////////////////////////////////////////
  115. class CFlowNode_StringConcat : public CFlowBaseNode<eNCT_Singleton>
  116. {
  117. public:
  118.         CFlowNode_StringConcat(SActivationInfo* pActInfo) {};
  119.  
  120.         virtual void GetConfiguration(SFlowNodeConfig& config)
  121.         {
  122.                 static const SInputPortConfig in_config[] = {
  123.                         InputPortConfig_Void("Set",        _HELP("Send string [String1+String2] to [Out]")),
  124.                         InputPortConfig<string>("String1", _HELP("First string to be concat with second string")),
  125.                         InputPortConfig<string>("String2", _HELP("Second string")),
  126.                         { 0 }
  127.                 };
  128.                 static const SOutputPortConfig out_config[] = {
  129.                         OutputPortConfig<string>("Out"),
  130.                         { 0 }
  131.                 };
  132.                 config.sDescription = _HELP("Concat two string values");
  133.                 config.pInputPorts = in_config;
  134.                 config.pOutputPorts = out_config;
  135.                 config.SetCategory(EFLN_APPROVED);
  136.         }
  137.         virtual void ProcessEvent(EFlowEvent evt, SActivationInfo* pActInfo)
  138.         {
  139.                 switch (evt)
  140.                 {
  141.                 case eFE_Activate:
  142.                 case eFE_Initialize:
  143.                         if (IsPortActive(pActInfo, 0))
  144.                         {
  145.                                 string str1 = GetPortString(pActInfo, 1);
  146.                                 string str2 = GetPortString(pActInfo, 2);
  147.                                 ActivateOutput(pActInfo, 0, str1 + str2);
  148.                         }
  149.                         break;
  150.                 }
  151.         };
  152.  
  153.         virtual void GetMemoryUsage(ICrySizer* s) const
  154.         {
  155.                 s->Add(*this);
  156.         }
  157. };
  158.  
  159. //////////////////////////////////////////////////////////////////////////
  160. class CFlowNode_StringWildcardExtract : public CFlowBaseNode<eNCT_Instanced>
  161. {
  162. public:
  163.         CFlowNode_StringWildcardExtract(SActivationInfo* pActInfo) {}
  164.         virtual IFlowNodePtr Clone(SActivationInfo *pActInfo) override
  165.         {
  166.                 return new CFlowNode_StringWildcardExtract(pActInfo);
  167.         }
  168.         virtual void GetMemoryUsage(ICrySizer* s) const override
  169.         {
  170.                 s->Add(*this);
  171.         }
  172.  
  173.         enum
  174.         {
  175.                 eMaxSupportedWildCards = 2,
  176.         };
  177.  
  178.         enum
  179.         {
  180.                 eIP_Extract = 0,
  181.                 eIP_Wildcard,
  182.                 eIP_Text,
  183.                 eIP_IgnoreCase,
  184.         };
  185.  
  186.         enum
  187.         {
  188.                 eOP_Succeeded = 0,
  189.                 eOP_Failed,
  190.                 eOP_FirstWildCardIndex,
  191.         };
  192.  
  193.         typedef CryFixedStringT<16> TPortName;
  194.  
  195.         virtual void GetConfiguration(SFlowNodeConfig& config) override
  196.         {
  197.                 static const SInputPortConfig in_config[] = {
  198.                         InputPortConfig_Void("Extract", _HELP("Perform extraction of the wildcards")),
  199.                         InputPortConfig<string>("Pattern", _HELP("Pattern containing the wildcards to extract")),
  200.                         InputPortConfig<string>("Text", _HELP("Text to be split according to the pattern")),
  201.                         InputPortConfig<bool>("IgnoreCase", false, _HELP("Tick to ignore the case")),
  202.                         { 0 }
  203.                 };
  204.                 static std::vector<SOutputPortConfig> s_outConfig;
  205.                 if (s_outConfig.empty())
  206.                 {
  207.                         static std::vector<TPortName> portNames;
  208.                         portNames.resize(eMaxSupportedWildCards);
  209.                         s_outConfig.reserve(eMaxSupportedWildCards + 3);
  210.  
  211.                         s_outConfig.push_back(OutputPortConfig_Void("Succeeded"));
  212.                         s_outConfig.push_back(OutputPortConfig_Void("Failed"));
  213.  
  214.                         for (int i = 0; i < eMaxSupportedWildCards; ++i)
  215.                         {
  216.                                 portNames[i].Format("WildCard%02d", i + 1);
  217.                                 s_outConfig.push_back(OutputPortConfig<string>(portNames[i].c_str()));
  218.                         }
  219.  
  220.                         s_outConfig.push_back(SOutputPortConfig { 0 });
  221.                 }
  222.                 config.sDescription = _HELP("Extract strings matching a pattern in another string.");
  223.                 config.pInputPorts = in_config;
  224.                 config.pOutputPorts = &s_outConfig[0];
  225.                 config.SetCategory(EFLN_APPROVED);
  226.         }
  227.  
  228.         virtual void ProcessEvent(EFlowEvent evt, SActivationInfo* pActInfo) override
  229.         {
  230.                 switch (evt)
  231.                 {
  232.                 case eFE_EditorInputPortDataSet:
  233.                         RefreshProcessor(pActInfo);
  234.                         break;
  235.                 case eFE_Initialize:
  236.                         RefreshProcessor(pActInfo);
  237.                         break;
  238.                 case eFE_Activate:
  239.                         if (IsPortActive(pActInfo, eIP_Wildcard))
  240.                         {
  241.                                 RefreshProcessor(pActInfo);
  242.                         }
  243.                         if (IsPortActive(pActInfo, eIP_Extract))
  244.                         {
  245.                                 PerformExtraction(pActInfo);
  246.                         }
  247.                         break;
  248.                 }
  249.         }
  250.  
  251.         void PerformExtraction(SActivationInfo* pActInfo)
  252.         {
  253.                 const string& text = GetPortString(pActInfo, eIP_Text);
  254.                 const bool bCaseSensitive = !GetPortBool(pActInfo, eIP_IgnoreCase);
  255.  
  256.                 const bool bSuccess = m_wildcardProcessor.Process(m_wildcardResult, text.c_str(), bCaseSensitive);
  257.                 if (bSuccess)
  258.                 {
  259.                         ActivateOutput(pActInfo, eOP_Succeeded, true);
  260.                         int wildcardIndex = 0;
  261.                         m_wildcardProcessor.ForEachWildCardResult(m_wildcardResult, [&wildcardIndex, pActInfo](const CryStringUtils::Wildcards::SConstraintMatch& match)
  262.                         {
  263.                                 if (wildcardIndex < eMaxSupportedWildCards)
  264.                                 {
  265.                                   int portId = eOP_FirstWildCardIndex + wildcardIndex;
  266.                                   string tempStr(match.szStart, match.size);
  267.                                   ActivateOutput(pActInfo, portId, tempStr);
  268.  
  269.                                   ++wildcardIndex;
  270.                                 }
  271.                         });
  272.                 }
  273.                 else
  274.                 {
  275.                         ActivateOutput(pActInfo, eOP_Failed, true);
  276.                 }
  277.         }
  278.  
  279.         void RefreshProcessor(SActivationInfo* pActInfo)
  280.         {
  281.                 const string& wildcardStr = GetPortString(pActInfo, eIP_Wildcard).c_str();
  282.                 m_wildcardProcessor.Reset(wildcardStr.c_str());
  283.                 if (m_wildcardProcessor.GetDescriptor().GetWildCardCount() > eMaxSupportedWildCards)
  284.                 {
  285.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "FG node [String:WildcardExtract] pattern \"%s\" has too many wildcard characters. %d is the maximum supported.", wildcardStr.c_str(), eMaxSupportedWildCards);
  286.                 }
  287.         }
  288.  
  289.         typedef CryStringUtils::Wildcards::CProcessor<CryStackStringT<char, 32>> TWildcardProcessor;
  290.         typedef CryStringUtils::Wildcards::CEvaluationResult                     TWildcardResult;
  291.  
  292.         TWildcardProcessor m_wildcardProcessor;
  293.         TWildcardResult    m_wildcardResult;
  294. };
  295.  
  296. REGISTER_FLOW_NODE("String:SetString", CFlowNode_SetString);
  297. REGISTER_FLOW_NODE("String:Compare", CFlowNode_CompareStrings);
  298. REGISTER_FLOW_NODE("String:Concat", CFlowNode_StringConcat);
  299. REGISTER_FLOW_NODE("String:WildcardExtract", CFlowNode_StringWildcardExtract);
  300.  
downloadFlowStringNodes.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top