senf/Utils/Console/Node.cci

   1 // $Id$
   2 //
   3 // Copyright (C) 2008
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 //
   6 // The contents of this file are subject to the Fraunhofer FOKUS Public License
   7 // Version 1.0 (the "License"); you may not use this file except in compliance
   8 // with the License. You may obtain a copy of the License at
   9 // http://senf.berlios.de/license.html
  10 //
  11 // The Fraunhofer FOKUS Public License Version 1.0 is based on,
  12 // but modifies the Mozilla Public License Version 1.1.
  13 // See the full license text for the amendments.
  14 //
  15 // Software distributed under the License is distributed on an "AS IS" basis,
  16 // WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  17 // for the specific language governing rights and limitations under the License.
  18 //
  19 // The Original Code is Fraunhofer FOKUS code.
  20 //
  21 // The Initial Developer of the Original Code is Fraunhofer-Gesellschaft e.V.
  22 // (registered association), Hansastraße 27 c, 80686 Munich, Germany.
  23 // All Rights Reserved.
  24 //
  25 // Contributor(s):
  26 //   Stefan Bund <g0dil@berlios.de>
  27
  28 /** \file
  29     \brief Node inline non-template implementation */
  30
  31 // Custom includes
  32
  33 #define prefix_ inline
  34 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  35
  36 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  37 // senf::console::GenericNode
  38
  39 prefix_ senf::console::GenericNode::ptr senf::console::GenericNode::thisptr()
  40 {
  41     return shared_from_this();
  42 }
  43
  44 prefix_ senf::console::GenericNode::cptr senf::console::GenericNode::thisptr()
  45     const
  46 {
  47     return shared_from_this();
  48 }
  49
  50 prefix_ senf::console::GenericNode::~GenericNode()
  51 {}
  52
  53 prefix_ std::string const & senf::console::GenericNode::name()
  54     const
  55 {
  56     return name_;
  57 }
  58
  59 prefix_ senf::console::GenericNode::GenericNode()
  60     : parent_ (0)
  61 {}
  62
  63 prefix_ void senf::console::GenericNode::name(std::string const & name)
  64 {
  65     name_ = name;
  66 }
  67
  68 prefix_ boost::shared_ptr<senf::console::DirectoryNode> senf::console::GenericNode::parent()
  69     const
  70 {
  71     return boost::static_pointer_cast<DirectoryNode>(
  72         parent_ ? parent_->shared_from_this() : ptr() );
  73 }
  74
  75 prefix_ senf::console::GenericNode::ptr senf::console::GenericNode::unlink()
  76 {
  77     if (parent_)
  78         return parent()->remove(name());
  79     else
  80         return thisptr();
  81 }
  82
  83 prefix_ void senf::console::GenericNode::help(std::ostream & output)
  84     const
  85 {
  86     v_help(output);
  87 }
  88
  89 prefix_ std::string senf::console::GenericNode::shorthelp()
  90     const
  91 {
  92     return v_shorthelp();
  93 }
  94
  95 prefix_ bool senf::console::GenericNode::operator==(GenericNode & other)
  96     const
  97 {
  98     return this == & other;
  99 }
 100
 101 prefix_ bool senf::console::GenericNode::operator!=(GenericNode & other)
 102     const
 103 {
 104     return this != & other;
 105 }
 106
 107 prefix_ bool senf::console::GenericNode::isDirectory()
 108     const
 109 {
 110     return dynamic_cast<DirectoryNode const *>(this);
 111 }
 112
 113 prefix_ bool senf::console::GenericNode::isLink()
 114     const
 115 {
 116     return dynamic_cast<LinkNode const *>(this);
 117 }
 118
 119 prefix_ bool senf::console::GenericNode::isCommand()
 120     const
 121 {
 122     return dynamic_cast<CommandNode const *>(this);
 123 }
 124
 125 prefix_ senf::console::GenericNode const & senf::console::GenericNode::followLink()
 126     const
 127 {
 128     return isLink()
 129         ? dynamic_cast<LinkNode const *>(this)->follow()
 130         : *this;
 131 }
 132
 133 prefix_ senf::console::GenericNode & senf::console::GenericNode::followLink()
 134 {
 135     return isLink()
 136         ? dynamic_cast<LinkNode *>(this)->follow()
 137         : *this;
 138 }
 139
 140 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 141 // senf::console::LinkNode
 142
 143 prefix_ senf::console::GenericNode & senf::console::LinkNode::follow()
 144     const
 145 {
 146     return *node_;
 147 }
 148
 149 prefix_ senf::console::LinkNode::ptr senf::console::LinkNode::create(GenericNode & node)
 150 {
 151     GenericNode::ptr p (node.thisptr());
 152     while ( p->isLink() )
 153         p = dynamic_cast<LinkNode&>(*p).follow().thisptr();
 154     return ptr(new LinkNode(*p));
 155 }
 156
 157 prefix_ senf::console::LinkNode::LinkNode(GenericNode & node)
 158     : node_ (node.thisptr())
 159 {}
 160
 161 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 162 // senf::console::DirectoryNode
 163
 164 prefix_ senf::console::DirectoryNode::ptr senf::console::DirectoryNode::create()
 165 {
 166     return ptr(new DirectoryNode());
 167 }
 168
 169 prefix_ bool senf::console::DirectoryNode::hasChild(std::string const & name)
 170     const
 171 {
 172     ChildMap::const_iterator i (children_.find(name));
 173     return i != children_.end();
 174 }
 175
 176 prefix_ senf::console::GenericNode &
 177 senf::console::DirectoryNode::get(std::string const & name)
 178     const
 179 {
 180     return getLink(name).followLink();
 181 }
 182
 183 prefix_ senf::console::DirectoryNode &
 184 senf::console::DirectoryNode::getDirectory(std::string const & name)
 185     const
 186 {
 187     try {
 188         return dynamic_cast<DirectoryNode&>(get(name));
 189     }
 190     SENF_WRAP_EXC(std::bad_cast)
 191 }
 192
 193 prefix_ senf::console::DirectoryNode &
 194 senf::console::DirectoryNode::operator[](std::string const & name)
 195     const
 196 {
 197     return getDirectory(name);
 198 }
 199
 200 prefix_ senf::console::CommandNode &
 201 senf::console::DirectoryNode::getCommand(std::string const & name)
 202     const
 203 {
 204     try {
 205         return dynamic_cast<CommandNode&>(get(name));
 206     }
 207     SENF_WRAP_EXC(std::bad_cast)
 208 }
 209
 210 prefix_ senf::console::CommandNode &
 211 senf::console::DirectoryNode::operator()(std::string const & name)
 212     const
 213 {
 214     return getCommand(name);
 215 }
 216
 217 prefix_ senf::console::DirectoryNode::ChildrenRange senf::console::DirectoryNode::children()
 218     const
 219 {
 220     return boost::make_iterator_range(children_.begin(), children_.end());
 221 }
 222
 223 prefix_ senf::console::DirectoryNode::ChildrenRange
 224 senf::console::DirectoryNode::completions(std::string const & s)
 225     const
 226 {
 227     return boost::make_iterator_range(children_.lower_bound(s),
 228                                       children_.lower_bound(s + "\xff"));
 229 }
 230
 231 prefix_ senf::console::DirectoryNode::DirectoryNode()
 232 {}
 233
 234 prefix_ senf::console::DirectoryNode &
 235 senf::console::DirectoryNode::doc(std::string const & doc)
 236 {
 237     doc_ = doc;
 238     return *this;
 239 }
 240
 241 prefix_ senf::console::DirectoryNode &
 242 senf::console::DirectoryNode::shortdoc(std::string const & doc)
 243 {
 244     shortdoc_ = doc;
 245     return *this;
 246 }
 247
 248 prefix_ senf::console::DirectoryNode::ptr senf::console::DirectoryNode::thisptr()
 249 {
 250     return boost::static_pointer_cast<DirectoryNode>(shared_from_this());
 251 }
 252
 253 prefix_ senf::console::DirectoryNode::cptr senf::console::DirectoryNode::thisptr()
 254     const
 255 {
 256     return boost::static_pointer_cast<DirectoryNode const>(shared_from_this());
 257 }
 258
 259 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 260 // senf::console::CommandNode
 261
 262 prefix_ senf::console::CommandNode::ptr senf::console::CommandNode::thisptr()
 263 {
 264     return boost::static_pointer_cast<CommandNode>(shared_from_this());
 265 }
 266
 267 prefix_ senf::console::CommandNode::cptr senf::console::CommandNode::thisptr()
 268     const
 269 {
 270     return boost::static_pointer_cast<CommandNode const>(shared_from_this());
 271 }
 272
 273 prefix_ senf::console::CommandNode::CommandNode()
 274 {}
 275
 276 prefix_ void senf::console::CommandNode::execute(std::ostream & output,
 277                                                  ParseCommandInfo const & command)
 278     const
 279 {
 280     boost::any rv;
 281     execute(rv, output, command);
 282 }
 283
 284 prefix_ void senf::console::CommandNode::execute(boost::any & rv, std::ostream & output,
 285                                                  ParseCommandInfo const & command)
 286     const
 287 {
 288     rv = boost::any();
 289     v_execute(rv, output, command);
 290 }
 291
 292 prefix_ void senf::console::CommandNode::operator()(std::ostream & output,
 293                                                     ParseCommandInfo const & command)
 294     const
 295 {
 296     execute(output, command);
 297 }
 298
 299 prefix_ void senf::console::CommandNode::operator()(boost::any & rv, std::ostream & output,
 300                                                     ParseCommandInfo const & command)
 301     const
 302 {
 303     execute(rv, output, command);
 304 }
 305
 306 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 307 // senf::console::SimpleCommandNode
 308
 309 prefix_ senf::console::SimpleCommandNode::SimpleCommandNode(Function const & fn)
 310     : fn_ (fn)
 311 {}
 312
 313 prefix_ senf::console::SimpleCommandNode::ptr
 314 senf::console::SimpleCommandNode::create(Function const & fn)
 315 {
 316     return ptr(new SimpleCommandNode(fn));
 317 }
 318
 319 prefix_ senf::console::SimpleCommandNode &
 320 senf::console::SimpleCommandNode::doc(std::string const & doc)
 321 {
 322     doc_ = doc;
 323     return *this;
 324 }
 325
 326 prefix_ senf::console::SimpleCommandNode &
 327 senf::console::SimpleCommandNode::shortdoc(std::string const & doc)
 328 {
 329     shortdoc_ = doc;
 330     return *this;
 331 }
 332
 333 prefix_ senf::console::SimpleCommandNode::ptr senf::console::SimpleCommandNode::thisptr()
 334 {
 335     return boost::static_pointer_cast<SimpleCommandNode>(shared_from_this());
 336 }
 337
 338 prefix_ senf::console::SimpleCommandNode::cptr senf::console::SimpleCommandNode::thisptr()
 339     const
 340 {
 341     return boost::static_pointer_cast<SimpleCommandNode const>(shared_from_this());
 342 }
 343
 344 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 345
 346 prefix_ senf::console::DirectoryNode & senf::console::provideDirectory(DirectoryNode & dir,
 347                                                                        std::string const & name)
 348 {
 349     return dir.hasChild(name) ? dir.getDirectory(name) : dir.add(name, factory::Directory());
 350 }
 351
 352
 353 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 354 // senf::console::factory::SimpleCommand
 355
 356 prefix_ senf::console::factory::SimpleCommand::SimpleCommand(SimpleCommandNode::Function fn)
 357     : node_ (SimpleCommandNode::create(fn))
 358 {}
 359
 360 prefix_ senf::console::SimpleCommandNode &
 361 senf::console::factory::SimpleCommand::create(DirectoryNode & dir, std::string const & name)
 362     const
 363 {
 364     return dir.add(name, node_);
 365 }
 366
 367 prefix_ senf::console::factory::SimpleCommand const &
 368 senf::console::factory::SimpleCommand::doc(std::string const & doc)
 369     const
 370 {
 371     node_->doc(doc);
 372     return *this;
 373 }
 374
 375 prefix_ senf::console::factory::SimpleCommand const &
 376 senf::console::factory::SimpleCommand::shortdoc(std::string const & doc)
 377     const
 378 {
 379     node_->shortdoc(doc);
 380     return *this;
 381 }
 382
 383 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 384 // senf::console::factory::Directory
 385
 386 prefix_ senf::console::factory::Directory::Directory()
 387     : node_ (DirectoryNode::create())
 388 {}
 389
 390 prefix_ senf::console::DirectoryNode &
 391 senf::console::factory::Directory::create(DirectoryNode & dir, std::string const & name)
 392     const
 393 {
 394     return dir.add(name, node_);
 395 }
 396
 397 prefix_ senf::console::factory::Directory const &
 398 senf::console::factory::Directory::doc(std::string const & doc)
 399     const
 400 {
 401     node_->doc(doc);
 402     return *this;
 403 }
 404
 405 prefix_ senf::console::factory::Directory const &
 406 senf::console::factory::Directory::shortdoc(std::string const & doc)
 407     const
 408 {
 409     node_->shortdoc(doc);
 410     return *this;
 411 }
 412
 413 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 414 // senf::console::factory::Link
 415
 416 prefix_ senf::console::factory::Link::Link(GenericNode & target)
 417     : node_ (LinkNode::create(target))
 418 {}
 419
 420 prefix_ senf::console::LinkNode & senf::console::factory::Link::create(DirectoryNode & dir,
 421                                                                        std::string const & name)
 422     const
 423 {
 424     return dir.add(name, node_);
 425 }
 426
 427 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 428 #undef prefix_
 429
 430 \f
 431 // Local Variables:
 432 // mode: c++
 433 // fill-column: 100
 434 // comment-column: 40
 435 // c-file-style: "senf"
 436 // indent-tabs-mode: nil
 437 // ispell-local-dictionary: "american"
 438 // compile-command: "scons -u test"
 439 // End: