nel/src/net/module_common.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17
  18 #include "stdnet.h"
  19 #include "nel/misc/sstring.h"
  20 #include "nel/net/module_common.h"
  21
  22 using namespace std;
  23 using namespace NLMISC;
  24
  25 namespace NLNET
  26 {
  27
  28         TParsedCommandLine::TParsedCommandLine(const TParsedCommandLine& copy)
  29                 :ParamName(copy.ParamName), ParamValue(copy.ParamValue)
  30         {
  31
  32
  33
  34                 uint first = 0, last = (uint)copy.SubParams.size();
  35                 SubParams.resize( last );
  36                 for (; first != last; ++first)
  37                 {
  38                         // calls recursively copy constructor
  39                         SubParams[first] = new TParsedCommandLine(*copy.SubParams[first]);
  40                 }
  41
  42         }
  43
  44         TParsedCommandLine::~TParsedCommandLine()
  45         {
  46                 clear();
  47         };
  48
  49         void TParsedCommandLine::clear()
  50         {
  51                 for (std::vector<TParsedCommandLine*>::iterator it=SubParams.begin(); it!=SubParams.end(); ++it)
  52                 {
  53                         delete (*it);
  54                 }
  55                 SubParams.clear();
  56                 ParamName.clear();
  57                 ParamValue.clear();
  58         }
  59
  60         bool TParsedCommandLine::parseParamList(const std::string &rawParamString)
  61         {
  62                 // Cleanup the struct
  63                 clear();
  64
  65                 return _parseParamList(rawParamString);
  66         }
  67
  68         std::string TParsedCommandLine::toString() const
  69         {
  70                 string ret;
  71
  72                 ret = ParamName;
  73                 if (!ParamValue.empty())
  74                 {
  75                         ret += " = "+ParamValue;
  76                 }
  77
  78                 if (!SubParams.empty())
  79                 {
  80                         ret += " ( ";
  81
  82                         for (uint i=0; i<SubParams.size(); ++i)
  83                         {
  84                                 if (i >0)
  85                                         ret += " ";
  86                                 ret += SubParams[i]->toString();
  87                         }
  88
  89                         ret += " ) ";
  90                 }
  91
  92                 return ret;
  93         }
  94
  95
  96
  97         bool TParsedCommandLine::_parseParamList(const std::string &rawParamString)
  98         {
  99                 CSString parsedString(rawParamString);
 100
 101                 for (CSString part = parsedString.strtok(" \t", true, false);
 102                         !part.empty();
 103                         part = parsedString.strtok(" \t", true, false))
 104                 {
 105                         if (part[0] == '(')
 106                         {
 107                                 // this is a sub parameter list
 108                                 if (SubParams.empty() || SubParams.back()->ParamName.empty())
 109                                 {
 110                                         nlwarning("While parsing param string '%s', missing param header", rawParamString.c_str());
 111                                         return false;
 112                                 }
 113                                 if (!SubParams.back()->ParamValue.empty())
 114                                 {
 115                                         nlwarning("While parsing param string '%s', Invalid sub param header '%s' for sub part '%s', must not define value",
 116                                                 rawParamString.c_str(),
 117                                                 SubParams.back()->ParamName.c_str(),
 118                                                 part.c_str());
 119
 120                                         return false;
 121                                 }
 122
 123                                 if (part[part.size()-1] != ')')
 124                                 {
 125                                         nlwarning("While parsing param string '%s', Invalid sub param value '%s' missing closing ')'",
 126                                                 rawParamString.c_str(),
 127                                                 part.c_str());
 128
 129                                         return false;
 130                                 }
 131
 132                                 part = part.stripBlockDelimiters();
 133
 134                                 if (!SubParams.back()->_parseParamList(part))
 135                                 {
 136                                         nlwarning("Error parsing sub param list for header '%s' in '%s'",
 137                                                 SubParams.back()->ParamName.c_str(),
 138                                                 rawParamString.c_str());
 139                                         return false;
 140                                 }
 141                         }
 142                         else if (part[part.size()-1] == ')')
 143                         {
 144                                 nlwarning("While parsing param string '%s', Invalid param value '%s' : missing openning '('",
 145                                         rawParamString.c_str(),
 146                                         part.c_str());
 147
 148                                 return false;
 149                         }
 150                         else if (part[0] == '\"')
 151                         {
 152                                 // this is a quoted parameter value
 153                                 if (SubParams.empty() || !SubParams.back()->ParamValue.empty())
 154                                 {
 155                                         nlwarning("While parsing param string '%s', param '%s' already have the value '%s'",
 156                                                 rawParamString.c_str(),
 157                                                 SubParams.back()->ParamName.c_str(),
 158                                                 SubParams.back()->ParamValue.c_str());
 159                                         return false;
 160                                 }
 161                                 SubParams.back()->ParamValue = part.unquote();
 162                         }
 163                         else
 164                         {
 165                                 // this is a simple param
 166                                 CSString name = part.splitTo('=', true, true);
 167                                 if (name.empty())
 168                                 {
 169                                         nlwarning("Can't find param name for value '%s' in the param string '%s'",
 170                                                 part.c_str(),
 171                                                 rawParamString.c_str());
 172                                         return false;
 173                                 }
 174                                 CSString value = part.strtok("=");
 175
 176                                 SubParams.push_back( new TParsedCommandLine() );
 177                                 SubParams.back()->ParamName = name;
 178                                 SubParams.back()->ParamValue = value;
 179                         }
 180                 }
 181
 182                 return true;
 183         }
 184
 185         const TParsedCommandLine *TParsedCommandLine::getParam(const std::string &name) const
 186         {
 187                 vector<string>  parts;
 188                 NLMISC::explode(name, string("."), parts);
 189
 190                 return _getParam(parts.begin(), parts.end());
 191         }
 192
 193         void TParsedCommandLine::setParam(const std::string &name, const std::string &value)
 194         {
 195                 vector<string>  parts;
 196                 NLMISC::explode(name, string("."), parts);
 197
 198                 if (!name.empty())
 199                 {
 200                         // at least one part in the name
 201                         // check if sub ojbcct exist
 202                         TParsedCommandLine *sub = _getParam(parts.begin(), (parts.begin()+1));
 203                         if (sub == NULL)
 204                         {
 205                                 TParsedCommandLine * newElem = new TParsedCommandLine();
 206                                 newElem->ParamName = parts[0];
 207                                 SubParams.push_back(newElem);
 208                                 sub = SubParams.back();
 209                         }
 210
 211                         if (!name.empty())
 212                         {
 213                                 // name is more deep, need to resurse
 214                                 parts.erase(parts.begin());
 215                                 std::string subName;
 216                                 join(parts, ".", subName);
 217                                 sub->setParam(subName, value);
 218                         }
 219                         else
 220                         {
 221                                 // last level, set the value
 222                                 sub->ParamValue = value;
 223                         }
 224                 }
 225         }
 226
 227         const TParsedCommandLine *TParsedCommandLine::_getParam(std::vector<std::string>::iterator it, std::vector<std::string>::iterator end) const
 228         {
 229                 return const_cast<TParsedCommandLine&>(*this)._getParam(it, end);
 230         }
 231
 232         TParsedCommandLine *TParsedCommandLine::_getParam(std::vector<std::string>::iterator it, std::vector<std::string>::iterator end)
 233         {
 234                 if (it == end)
 235                 {
 236                         // end of recursion, we found the searched param
 237                         return this;
 238                 }
 239
 240                 // look for sub param
 241                 for (uint i=0; i<SubParams.size(); ++i)
 242                 {
 243                         if (SubParams[i]->ParamName == *it)
 244                                 return SubParams[i]->_getParam(++it, end);
 245                 }
 246
 247                 // parameter not found
 248                 return NULL;
 249         }
 250
 251
 252 } // namespace NLMISC