src/gromacs/selection/symrec.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2009,2010,2011,2012, by the GROMACS development team, led by
   5  * David van der Spoel, Berk Hess, Erik Lindahl, and including many
   6  * others, as listed in the AUTHORS file in the top-level source
   7  * directory and at http://www.gromacs.org.
   8  *
   9  * GROMACS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1
  12  * of the License, or (at your option) any later version.
  13  *
  14  * GROMACS is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with GROMACS; if not, see
  21  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  23  *
  24  * If you want to redistribute modifications to GROMACS, please
  25  * consider that scientific software is very special. Version
  26  * control is crucial - bugs must be traceable. We will be happy to
  27  * consider code for inclusion in the official distribution, but
  28  * derived work must not be called official GROMACS. Details are found
  29  * in the README & COPYING files - if they are missing, get the
  30  * official version at http://www.gromacs.org.
  31  *
  32  * To help us fund GROMACS development, we humbly ask that you cite
  33  * the research papers on the package. Check out http://www.gromacs.org.
  34  */
  35 /*! \internal \file
  36  * \brief
  37  * Implements classes in symrec.h.
  38  *
  39  * \author Teemu Murtola <teemu.murtola@gmail.com>
  40  * \ingroup module_selection
  41  */
  42 #include <map>
  43 #include <string>
  44 #include <utility>
  45
  46 #include "gromacs/legacyheaders/macros.h"
  47
  48 #include "gromacs/utility/exceptions.h"
  49 #include "gromacs/utility/gmxassert.h"
  50 #include "gromacs/utility/stringutil.h"
  51 #include "gromacs/utility/uniqueptr.h"
  52
  53 #include "poscalc.h"
  54 #include "selelem.h"
  55 #include "symrec.h"
  56
  57 namespace gmx
  58 {
  59
  60 /********************************************************************
  61  * SelectionParserSymbol
  62  */
  63
  64 /*! \internal \brief
  65  * Private implementation class for SelectionParserSymbol.
  66  *
  67  * \ingroup module_selection
  68  */
  69 class SelectionParserSymbol::Impl
  70 {
  71     public:
  72         /*! \brief
  73          * Initializes a symbol.
  74          *
  75          * \param[in] type  Type for the symbol.
  76          * \param[in] name  Name for the symbol.
  77          *
  78          * The symbol table is responsible for initializing the \a meth_ and
  79          * \a var_ members as appropriate.
  80          */
  81         Impl(SymbolType type, const char *name)
  82             : name_(name), type_(type), meth_(NULL)
  83         {
  84         }
  85
  86         //! Name of the symbol.
  87         std::string                     name_;
  88         //! Type of the symbol.
  89         SymbolType                      type_;
  90         //! Pointer to the method structure (\ref MethodSymbol).
  91         gmx_ana_selmethod_t            *meth_;
  92         //! Pointer to the variable value (\ref VariableSymbol).
  93         SelectionTreeElementPointer     var_;
  94 };
  95
  96 SelectionParserSymbol::SelectionParserSymbol(Impl *impl)
  97     : impl_(impl)
  98 {
  99 }
 100
 101 SelectionParserSymbol::~SelectionParserSymbol()
 102 {
 103 }
 104
 105 const std::string &
 106 SelectionParserSymbol::name() const
 107 {
 108     return impl_->name_;
 109 }
 110
 111 SelectionParserSymbol::SymbolType
 112 SelectionParserSymbol::type() const
 113 {
 114     return impl_->type_;
 115 }
 116
 117 gmx_ana_selmethod_t *
 118 SelectionParserSymbol::methodValue() const
 119 {
 120     GMX_RELEASE_ASSERT(type() == MethodSymbol,
 121                        "Attempting to get method handle for a non-method symbol");
 122     return impl_->meth_;
 123 }
 124
 125 const gmx::SelectionTreeElementPointer &
 126 SelectionParserSymbol::variableValue() const
 127 {
 128     GMX_RELEASE_ASSERT(type() == VariableSymbol,
 129                        "Attempting to get variable value for a non-variable symbol");
 130     return impl_->var_;
 131 }
 132
 133 /********************************************************************
 134  * SelectionParserSymbolTable::Impl
 135  */
 136
 137 /*! \internal \brief
 138  * Private implementation class for SelectionParserSymbolTable.
 139  *
 140  * All methods in this class may throw std::bad_alloc if out of memory.
 141  *
 142  * \ingroup module_selection
 143  */
 144 class SelectionParserSymbolTable::Impl
 145 {
 146     public:
 147         //! Smart pointer type for managing a SelectionParserSymbol.
 148         typedef gmx::gmx_unique_ptr<SelectionParserSymbol>::type
 149             SymbolPointer;
 150         //! Container type for the list of symbols.
 151         typedef std::map<std::string, SymbolPointer> SymbolMap;
 152
 153         /*! \brief
 154          * Adds a symbol to the symbol list.
 155          *
 156          * \param[in] symbol  Symbol to add.
 157          */
 158         void addSymbol(SymbolPointer symbol);
 159         //! Adds the reserved symbols to this symbol table.
 160         void addReservedSymbols();
 161         //! Adds the position symbols to this symbol table.
 162         void addPositionSymbols();
 163
 164         //! Symbols in this symbol table.
 165         SymbolMap               symbols_;
 166 };
 167
 168 void
 169 SelectionParserSymbolTable::Impl::addSymbol(SymbolPointer symbol)
 170 {
 171     symbols_.insert(std::make_pair(symbol->name(), move(symbol)));
 172 }
 173
 174 void
 175 SelectionParserSymbolTable::Impl::addReservedSymbols()
 176 {
 177     const char *const sym_reserved[] = {
 178         "group",
 179         "to",
 180         "not",
 181         "and",
 182         "or",
 183         "xor",
 184         "yes",
 185         "no",
 186         "on",
 187         "off",
 188         "help",
 189     };
 190
 191     for (size_t i = 0; i < asize(sym_reserved); ++i)
 192     {
 193         SymbolPointer sym(new SelectionParserSymbol(
 194                                   new SelectionParserSymbol::Impl(
 195                                           SelectionParserSymbol::ReservedSymbol, sym_reserved[i])));
 196         addSymbol(move(sym));
 197     }
 198 }
 199
 200 void
 201 SelectionParserSymbolTable::Impl::addPositionSymbols()
 202 {
 203     const char *const *postypes
 204         = gmx::PositionCalculationCollection::typeEnumValues;
 205     for (int i = 0; postypes[i] != NULL; ++i)
 206     {
 207         SymbolPointer sym(new SelectionParserSymbol(
 208                                   new SelectionParserSymbol::Impl(
 209                                           SelectionParserSymbol::PositionSymbol, postypes[i])));
 210         addSymbol(move(sym));
 211     }
 212 }
 213
 214 /********************************************************************
 215  * SelectionParserSymbolIterator
 216  */
 217
 218 /*! \internal \brief
 219  * Private implementation class for SelectionParserSymbolIterator.
 220  *
 221  * \ingroup module_selection
 222  */
 223 class SelectionParserSymbolIterator::Impl
 224 {
 225     public:
 226         //! Shorthand for the underlying iterator type.
 227         typedef SelectionParserSymbolTable::Impl::SymbolMap::const_iterator
 228             IteratorType;
 229
 230         /*! \brief
 231          * Constructs an end iterator.
 232          *
 233          * \param[in] end  Iterator to the end of the iterated container.
 234          */
 235         explicit Impl(IteratorType end)
 236             : iter_(end), end_(end)
 237         {
 238         }
 239         /*! \brief
 240          * Constructs an iterator.
 241          *
 242          * \param[in] iter Iterator to the current symbol.
 243          * \param[in] end  Iterator to the end of the iterated container.
 244          */
 245         Impl(IteratorType iter, IteratorType end)
 246             : iter_(iter), end_(end)
 247         {
 248         }
 249
 250         //! Underlying iterator to the symbol container.
 251         IteratorType            iter_;
 252         //! End of the symbol container being iterated.
 253         IteratorType            end_;
 254 };
 255
 256 SelectionParserSymbolIterator::SelectionParserSymbolIterator(Impl *impl)
 257     : impl_(impl)
 258 {
 259 }
 260
 261 SelectionParserSymbolIterator::SelectionParserSymbolIterator(
 262         const SelectionParserSymbolIterator &other)
 263     : impl_(new Impl(*other.impl_))
 264 {
 265 }
 266
 267 SelectionParserSymbolIterator::~SelectionParserSymbolIterator()
 268 {
 269 }
 270
 271 SelectionParserSymbolIterator &SelectionParserSymbolIterator::operator=(
 272         const SelectionParserSymbolIterator &other)
 273 {
 274     impl_.reset(new Impl(*other.impl_));
 275     return *this;
 276 }
 277
 278 bool SelectionParserSymbolIterator::operator==(
 279         const SelectionParserSymbolIterator &other) const
 280 {
 281     return impl_->iter_ == other.impl_->iter_;
 282 }
 283
 284 const SelectionParserSymbol &SelectionParserSymbolIterator::operator*() const
 285 {
 286     return *impl_->iter_->second;
 287 }
 288
 289 SelectionParserSymbolIterator &SelectionParserSymbolIterator::operator++()
 290 {
 291     SelectionParserSymbol::SymbolType type = impl_->iter_->second->type();
 292     do
 293     {
 294         ++impl_->iter_;
 295     }
 296     while (impl_->iter_ != impl_->end_ && impl_->iter_->second->type() != type);
 297     return *this;
 298 }
 299
 300 /********************************************************************
 301  * SelectionParserSymbolTable
 302  */
 303
 304 SelectionParserSymbolTable::SelectionParserSymbolTable()
 305     : impl_(new Impl)
 306 {
 307     impl_->addReservedSymbols();
 308     impl_->addPositionSymbols();
 309 }
 310
 311 SelectionParserSymbolTable::~SelectionParserSymbolTable()
 312 {
 313 }
 314
 315 const SelectionParserSymbol *
 316 SelectionParserSymbolTable::findSymbol(const std::string &name,
 317                                        bool               bExact) const
 318 {
 319     Impl::SymbolMap::const_iterator sym = impl_->symbols_.lower_bound(name);
 320     if (sym == impl_->symbols_.end())
 321     {
 322         return NULL;
 323     }
 324     if (sym->second->name() == name)
 325     {
 326         return sym->second.get();
 327     }
 328     if (!bExact && startsWith(sym->second->name(), name))
 329     {
 330         Impl::SymbolMap::const_iterator next = sym;
 331         ++next;
 332         if (next != impl_->symbols_.end()
 333             && startsWith(next->second->name(), name))
 334         {
 335             GMX_THROW(InvalidInputError("'" + name + "' is ambiguous"));
 336         }
 337         if (sym->second->type() == SelectionParserSymbol::MethodSymbol)
 338         {
 339             return sym->second.get();
 340         }
 341     }
 342     return NULL;
 343 }
 344
 345 SelectionParserSymbolIterator
 346 SelectionParserSymbolTable::beginIterator(SelectionParserSymbol::SymbolType type) const
 347 {
 348     Impl::SymbolMap::const_iterator sym;
 349     Impl::SymbolMap::const_iterator end = impl_->symbols_.end();
 350     for (sym = impl_->symbols_.begin(); sym != end; ++sym)
 351     {
 352         if (sym->second->type() == type)
 353         {
 354             return SelectionParserSymbolIterator(
 355                     new SelectionParserSymbolIterator::Impl(sym, end));
 356         }
 357     }
 358     return endIterator();
 359 }
 360
 361 SelectionParserSymbolIterator
 362 SelectionParserSymbolTable::endIterator() const
 363 {
 364     return SelectionParserSymbolIterator(
 365             new SelectionParserSymbolIterator::Impl(impl_->symbols_.end()));
 366 }
 367
 368 void
 369 SelectionParserSymbolTable::addVariable(const char                             *name,
 370                                         const gmx::SelectionTreeElementPointer &sel)
 371 {
 372     // In the current parser implementation, a syntax error is produced before
 373     // this point is reached, but the check is here for robustness.
 374     Impl::SymbolMap::const_iterator other = impl_->symbols_.find(name);
 375     if (other != impl_->symbols_.end())
 376     {
 377         if (other->second->type() == SelectionParserSymbol::VariableSymbol)
 378         {
 379             GMX_THROW(InvalidInputError(
 380                               formatString("Reassigning variable '%s' is not supported",
 381                                            name)));
 382         }
 383         else
 384         {
 385             GMX_THROW(InvalidInputError(
 386                               formatString("Variable name '%s' conflicts with a reserved keyword",
 387                                            name)));
 388         }
 389     }
 390     Impl::SymbolPointer sym(new SelectionParserSymbol(
 391                                     new SelectionParserSymbol::Impl(
 392                                             SelectionParserSymbol::VariableSymbol, name)));
 393     sym->impl_->var_ = sel;
 394     impl_->addSymbol(move(sym));
 395 }
 396
 397 void
 398 SelectionParserSymbolTable::addMethod(const char          *name,
 399                                       gmx_ana_selmethod_t *method)
 400 {
 401     if (impl_->symbols_.find(name) != impl_->symbols_.end())
 402     {
 403         GMX_THROW(APIError(
 404                           formatString("Method name '%s' conflicts with another symbol",
 405                                        name)));
 406     }
 407     Impl::SymbolPointer sym(new SelectionParserSymbol(
 408                                     new SelectionParserSymbol::Impl(
 409                                             SelectionParserSymbol::MethodSymbol, name)));
 410     sym->impl_->meth_ = method;
 411     impl_->addSymbol(move(sym));
 412 }
 413
 414 } // namespace gmx