1. 01 Jun, 2017 2 commits
  2. 19 May, 2017 2 commits
  3. 18 May, 2017 6 commits
  4. 17 May, 2017 9 commits
  5. 16 May, 2017 2 commits
    • Mark OLESEN's avatar
      ENH: cleanup wordRe interfaces etc. · a8d2ebf2
      Mark OLESEN authored
      - ensure that the string-related classes have consistently similar
        matching methods. Use operator()(const std::string) as an entry
        point for the match() method, which makes it easier to use for
        filters and predicates. In some cases this will also permit using
        a HashSet as a match predicate.
      
      regExp
      ====
      - the set method now returns a bool to signal that the requested
        pattern was compiled.
      
      wordRe
      ====
      - have separate constructors with the compilation option (was previously
        a default parameter). This leaves the single parameter constructor
        explicit, but the two parameter version is now non-explicit, which
        makes it easier to use when building lists.
      
      - renamed compile-option from REGEX (to REGEXP) for consistency with
        with the <regex.h>, <regex> header names etc.
      
      wordRes
      ====
      - renamed from wordReListMatcher -> wordRes. For reduced typing and
        since it behaves as an entity only slightly related to its underlying
        list nature.
      
      - Provide old name as typedef and include for code transition.
      
      - pass through some list methods into wordRes
      
      hashedWordList
      ====
      - hashedWordList[const word& name] now returns a -1 if the name is is
        not found in the list of indices. That has been a pending change
        ever since hashedWordList was generalized out of speciesTable
        (Oct-2010).
      
      - add operator()(const word& name) for easy use as a predicate
      
      STYLE: adjust parameter names in stringListOps
      
      - reflect if the parameter is being used as a primary matcher, or the
        matcher will be derived from the parameter.
        For example,
            (const char* re), which first creates a regExp
            versus (const regExp& matcher) which is used directly.
      a8d2ebf2
    • Mark OLESEN's avatar
      ENH: pass through doc/Allwmake arguments, add -config, -dir options · c1c6243c
      Mark OLESEN authored
      - can run doxygen with an alternative Doxyfile, which is useful
        when verifying generated content for particular classes.
        Eg,
            PATH/doc/Allwmake -dir $PWD
      c1c6243c
  6. 15 May, 2017 5 commits
  7. 14 May, 2017 3 commits
    • Mark OLESEN's avatar
      BUG: hashtable key_iterator ++ operator returning incorrect type · 4b0d1632
      Mark OLESEN authored
      ENH: ensure std::distance works with hashtable iterators
      4b0d1632
    • Mark OLESEN's avatar
      ENH: avoid std::distance for std::initializer_list · 0c53a815
      Mark OLESEN authored
      - std::initializer_list has its own size() method, so no need to use
        std::distance.
      
      STYLE/BUG: use separate iterator de-reference and increment in List
      
      - avoids unnecessary copying of iterators, and avoids any potentially
        odd behaviour with the combination with incrementing.
      
      ENH: support construct from iterator pair for DynamicList, SortableList
      0c53a815
    • Mark OLESEN's avatar
      ENH: improvements to labelRange const_iterator · 83669e28
      Mark OLESEN authored
      - inherit from std::iterator to obtain the full STL typedefs, meaning
        that std::distance works and the following is now possible:
      
            labelRange range(100, 1500);
            scalarList list(range.begin(), range.end());
      
        --
        Note that this does not work (mismatched data-types):
      
            scalarList list = identity(12345);
      
        But this does, since the *iter promotes label to scalar:
      
            labelList ident = identity(12345);
            scalarList list(ident.begin(), ident.end());
      
        It is however more than slightly wasteful to create a labelList
        just for initializing a scalarList. An alternative could be a
        a labelRange for the same purpose.
      
            labelRange ident = labelRange::identity(12345);
            scalarList list(ident.begin(), ident.end());
      
        Or this
            scalarList list
            (
                labelRange::null.begin(),
                labelRange::identity(12345).end()
            );
      83669e28
  8. 12 May, 2017 1 commit
  9. 11 May, 2017 1 commit
    • Mark OLESEN's avatar
      ENH: added HashTable 'lookup' and 'retain' methods · f73b5b62
      Mark OLESEN authored
      - lookup(): with a default value (const access)
        For example,
            Map<label> something;
            value = something.lookup(key, -1);
      
          being equivalent to the following:
      
            Map<label> something;
            value = -1;  // bad value
            if (something.found(key))
            {
                value = something[key];
            }
      
          except that lookup also makes it convenient to handle const references.
          Eg,
      
            const labelList& ids = someHash.lookup(key, labelList());
      
      - For consistency, provide a two parameter HashTable '()' operator.
        The lookup() method is, however, normally preferable when
        const-only access is to be ensured.
      
      - retain(): the counterpart to erase(), it only retains entries
        corresponding to the listed keys.
      
        For example,
            HashTable<someType> largeCache;
            wordHashSet preserve = ...;
      
            largeCache.retain(preserve);
      
          being roughly equivalent to the following two-stage process,
          but with reduced overhead and typing, and fewer potential mistakes.
      
            HashTable<someType> largeCache;
            wordHashSet preserve = ...;
      
            {
                wordHashSet cull(largeCache.toc()); // all keys
                cull.erase(preserve);               // except those to preserve
                largeCache.erase(cull);             //
            }
      
        The HashSet &= operator and retain() are functionally equivalent,
        but retain() also works with dissimilar value types.
      f73b5b62
  10. 10 May, 2017 2 commits
  11. 08 May, 2017 6 commits
  12. 07 May, 2017 1 commit