slhaea.h

Go to the documentation of this file.

// SLHAea - containers for SUSY Les Houches Accord input/output
// Copyright © 2009-2011 Frank S. Thomas <frank@timepit.eu>
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#ifndef SLHAEA_H
#define SLHAEA_H

#include <algorithm>
#include <cctype>
#include <cstddef>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <sstream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/join.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/lexical_cast.hpp>

namespace SLHAea {

// auxiliary functions
template<class Target, class Source> inline Target
to(const Source& arg)
{ return boost::lexical_cast<Target>(arg); }

template<class Source> inline std::string
to_string(const Source& arg)
{ return boost::lexical_cast<std::string>(arg); }

template<class Source> inline std::string
to_string(const Source& arg, int precision)
{
  std::ostringstream output;
  output << std::setprecision(precision) << std::scientific << arg;
  return output.str();
}


namespace detail {

inline bool
is_all_whitespace(const std::string& str)
{ return str.find_first_not_of(" \t\n\v\f\r") == std::string::npos; }

inline std::string
to_upper_copy(const std::string& str)
{
  std::string str_upper(str.length(), char());
  std::transform(str.begin(), str.end(), str_upper.begin(),
    static_cast<int (*)(int)>(std::toupper));
  return str_upper;
}

inline void
trim_left(std::string& str)
{
  const std::size_t startpos = str.find_first_not_of(" \t\n\v\f\r");
  if (startpos != std::string::npos) str.erase(0, startpos);
  else str.clear();
}

inline void
trim_right(std::string& str)
{
  const std::size_t endpos = str.find_last_not_of(" \t\n\v\f\r");
  if (endpos != std::string::npos) str.erase(endpos + 1);
  else str.clear();
}

} // namespace detail


// forward declarations
class Line;
class Block;
class Coll;
struct Key;

inline std::ostream& operator<<(std::ostream& os, const Line& line);
inline std::ostream& operator<<(std::ostream& os, const Block& block);
inline std::ostream& operator<<(std::ostream& os, const Coll& coll);
inline std::ostream& operator<<(std::ostream& os, const Key& key);


class Line
{
private:
  typedef std::vector<std::string> impl_type;

public:
  typedef std::string                       value_type;
  typedef std::string&                      reference;
  typedef const std::string&                const_reference;
  typedef impl_type::iterator               iterator;
  typedef impl_type::const_iterator         const_iterator;
  typedef impl_type::reverse_iterator       reverse_iterator;
  typedef impl_type::const_reverse_iterator const_reverse_iterator;
  typedef impl_type::pointer                pointer;
  typedef impl_type::const_pointer          const_pointer;
  typedef impl_type::difference_type        difference_type;
  typedef impl_type::size_type              size_type;

  // NOTE: The compiler-generated copy constructor and assignment
  //   operator for this class are just fine, so we don't need to
  //   write our own.

  Line() : impl_(), columns_() {}

  Line(const std::string& line) : impl_(), columns_()
  { str(line); }

  Line&
  operator=(const std::string& line)
  {
    str(line);
    return *this;
  }

  Line&
  operator+=(const std::string& arg)
  {
    append(arg);
    return *this;
  }

  template<class T> Line&
  operator<<(const T& field)
  {
    std::string field_str = to_string(field);
    detail::trim_right(field_str);
    if (field_str.empty()) return *this;

    if (contains_comment())
    { back() += field_str; }
    else
    {
      detail::trim_left(field_str);
      impl_.push_back(field_str);
      reformat();
    }
    return *this;
  }

  Line&
  append(const std::string& arg)
  {
    str(str() + arg);
    return *this;
  }

  Line&
  str(const std::string& line)
  {
    clear();
    static const std::string whitespace = " \t\v\f\r";
    const std::size_t last_non_ws =
      line.substr(0, line.find('\n')).find_last_not_of(whitespace);
    if (last_non_ws == std::string::npos) return *this;

    const std::string trimmed_line = line.substr(0, last_non_ws + 1);
    const std::size_t comment_pos = trimmed_line.find('#');
    const std::string data = trimmed_line.substr(0, comment_pos);

    std::size_t pos1 = data.find_first_not_of(whitespace, 0);
    std::size_t pos2 = data.find_first_of(whitespace, pos1);

    while (pos1 != std::string::npos)
    {
      impl_.push_back(data.substr(pos1, pos2 - pos1));
      columns_.push_back(pos1);

      pos1 = data.find_first_not_of(whitespace, pos2);
      pos2 = data.find_first_of(whitespace, pos1);
    }

    if (comment_pos != std::string::npos)
    {
      impl_.push_back(trimmed_line.substr(comment_pos));
      columns_.push_back(comment_pos);
    }
    return *this;
  }

  std::string
  str() const
  {
    if (empty()) return "";

    std::ostringstream output;
    int length = 0, spaces = 0;

    const_iterator field = begin();
    std::vector<std::size_t>::const_iterator column = columns_.begin();
    for (; field != end() && column != columns_.end(); ++field, ++column)
    {
      spaces = std::max(0, static_cast<int>(*column) - length + 1);
      length += spaces + field->length();

      output << std::setw(spaces) << " " << *field;
    }
    return output.str().substr(1);
  }

  // element access
  reference
  operator[](size_type n)
  { return impl_[n]; }

  const_reference
  operator[](size_type n) const
  { return impl_[n]; }

  reference
  at(size_type n)
  { return impl_.at(n); }

  const_reference
  at(size_type n) const
  { return impl_.at(n); }

  reference
  front()
  { return impl_.front(); }

  const_reference
  front() const
  { return impl_.front(); }

  reference
  back()
  { return impl_.back(); }

  const_reference
  back() const
  { return impl_.back(); }

  // iterators
  iterator
  begin()
  { return impl_.begin(); }

  const_iterator
  begin() const
  { return impl_.begin(); }

  const_iterator
  cbegin() const
  { return impl_.begin(); }

  iterator
  end()
  { return impl_.end(); }

  const_iterator
  end() const
  { return impl_.end(); }

  const_iterator
  cend() const
  { return impl_.end(); }

  reverse_iterator
  rbegin()
  { return impl_.rbegin(); }

  const_reverse_iterator
  rbegin() const
  { return impl_.rbegin(); }

  const_reverse_iterator
  crbegin() const
  { return impl_.rbegin(); }

  reverse_iterator
  rend()
  { return impl_.rend(); }

  const_reverse_iterator
  rend() const
  { return impl_.rend(); }

  const_reverse_iterator
  crend() const
  { return impl_.rend(); }

  // introspection
  bool
  is_block_def() const
  {
    if (size() < 2) return false;

    const_iterator field = begin();
    return is_block_specifier(*field) && !is_comment(*++field);
  }

  bool
  is_comment_line() const
  { return !empty() && is_comment(front()); }

  bool
  is_data_line() const
  { return !empty() && !is_comment(front()) && !is_block_specifier(front()); }

  // capacity
  size_type
  size() const
  { return impl_.size(); }

  size_type
  data_size() const
  { return std::distance(begin(), std::find_if(begin(), end(), is_comment)); }

  size_type
  max_size() const
  { return impl_.max_size(); }

  bool
  empty() const
  { return impl_.empty(); }

  // modifiers
  void
  swap(Line& line)
  {
    impl_.swap(line.impl_);
    columns_.swap(line.columns_);
  }

  void
  clear()
  {
    impl_.clear();
    columns_.clear();
  }

  void
  reformat()
  {
    if (empty()) return;

    columns_.clear();
    const_iterator field = begin();
    std::size_t pos1 = 0, pos2 = 0;

    if (is_block_specifier(*field))
    {
      pos1 = 0;
      pos2 = pos1 + field->length();
      columns_.push_back(pos1);

      if (++field == end()) return;

      pos1 = pos2 + 1;
      pos2 = pos1 + field->length();
      columns_.push_back(pos1);
    }
    else if (is_comment(*field))
    {
      pos1 = 0;
      pos2 = pos1 + field->length();
      columns_.push_back(pos1);
    }
    else
    {
      pos1 = shift_width_;
      pos2 = pos1 + field->length();
      columns_.push_back(pos1);
    }

    while (++field != end())
    {
      pos1 = pos2 + calc_spaces_for_indent(pos2);
      if (starts_with_sign(*field)) --pos1;
      pos2 = pos1 + field->length();
      columns_.push_back(pos1);
    }
  }

  void
  comment()
  { if (!empty()) str("#" + str()); }

  void
  uncomment()
  {
    if (!empty() && is_comment(front()))
    {
      front().erase(0, 1);
      str(str());
    }
  }

private:
  bool
  contains_comment() const
  { return std::find_if(rbegin(), rend(), is_comment) != rend(); }

  static std::size_t
  calc_spaces_for_indent(const std::size_t& pos)
  {
    std::size_t width = shift_width_ - (pos % shift_width_);
    if (width < min_width_) width += shift_width_;
    return width;
  }

  static bool
  is_block_specifier(const value_type& field)
  {
    static const std::size_t specifier_length = 5;
    if (field.length() != specifier_length) return false;

    const value_type field_upper = detail::to_upper_copy(field);
    return (field_upper == "BLOCK") || (field_upper == "DECAY");
  }

  static bool
  is_comment(const value_type& field)
  { return !field.empty() && field[0] == '#'; }

  template<class T> Line&
  insert_fundamental_type(const T& arg)
  {
    static const int digits = std::numeric_limits<T>::digits10;
    return *this << to_string(arg, digits);
  }

  static bool
  starts_with_sign(const value_type& field)
  { return !field.empty() && (field[0] == '-' || field[0] == '+'); }

private:
  impl_type impl_;
  std::vector<std::size_t> columns_;

  static const std::size_t shift_width_ = 4;
  static const std::size_t min_width_   = 2;
};

template<> inline Line&
Line::operator<< <float>(const float& number)
{
  insert_fundamental_type(number);
  return *this;
}

template<> inline Line&
Line::operator<< <double>(const double& number)
{
  insert_fundamental_type(number);
  return *this;
}

template<> inline Line&
Line::operator<< <long double>(const long double& number)
{
  insert_fundamental_type(number);
  return *this;
}


class Block
{
private:
  typedef std::vector<Line> impl_type;

public:
  typedef std::vector<std::string>          key_type;
  typedef Line                              value_type;
  typedef Line&                             reference;
  typedef const Line&                       const_reference;
  typedef impl_type::iterator               iterator;
  typedef impl_type::const_iterator         const_iterator;
  typedef impl_type::reverse_iterator       reverse_iterator;
  typedef impl_type::const_reverse_iterator const_reverse_iterator;
  typedef impl_type::pointer                pointer;
  typedef impl_type::const_pointer          const_pointer;
  typedef impl_type::difference_type        difference_type;
  typedef impl_type::size_type              size_type;

  // NOTE: The compiler-generated copy constructor and assignment
  //   operator for this class are just fine, so we don't need to
  //   write our own.

  explicit
  Block(const std::string& name = "") : name_(name), impl_() {}

  explicit
  Block(std::istream& is) : name_(), impl_()
  { read(is); }

  static Block
  from_str(const std::string& block)
  {
    std::istringstream input(block);
    return Block(input);
  }

  void
  name(const std::string& newName)
  { name_ = newName; }

  const std::string&
  name() const
  { return name_; }

  void
  rename(const std::string& newName)
  {
    name(newName);
    iterator block_def = find_block_def();
    if (block_def != end()) (*block_def)[1] = newName;
  }

  Block&
  read(std::istream& is)
  {
    std::string line_str;
    value_type line;

    std::size_t def_count = 0;
    bool nameless = name().empty();

    while (std::getline(is, line_str))
    {
      if (detail::is_all_whitespace(line_str)) continue;

      line.str(line_str);
      if (line.is_block_def())
      {
        if (++def_count > 1)
        {
          is.seekg(-line_str.length()-1, std::ios_base::cur);
          break;
        }
        if (nameless)
        {
          name(line[1]);
          nameless = false;
        }
      }
      push_back(line);
    }
    return *this;
  }

  Block&
  str(const std::string& block)
  {
    std::istringstream input(block);
    clear();
    read(input);
    return *this;
  }

  std::string
  str() const
  {
    std::ostringstream output;
    output << *this;
    return output.str();
  }

  // element access
  reference
  operator[](const key_type& key)
  {
    iterator line = find(key);
    if (line != end()) return *line;

    push_back(value_type());
    return back();
  }

  reference
  operator[](const std::vector<int>& key)
  { return (*this)[cont_to_key(key)]; }

  reference
  operator[](const std::string& key)
  { return (*this)[key_type(1, key)]; }

  reference
  operator[](int key)
  { return (*this)[key_type(1, to_string(key))]; }

  reference
  at(const key_type& key)
  {
    iterator line = find(key);
    if (line != end()) return *line;

    throw std::out_of_range(
      "SLHAea::Block::at(‘" + boost::join(key, ",") + "’)");
  }

  const_reference
  at(const key_type& key) const
  {
    const_iterator line = find(key);
    if (line != end()) return *line;

    throw std::out_of_range(
      "SLHAea::Block::at(‘" + boost::join(key, ",") + "’)");
  }

  reference
  at(const std::vector<int>& key)
  { return at(cont_to_key(key)); }

  const_reference
  at(const std::vector<int>& key) const
  { return at(cont_to_key(key)); }

  reference
  at(const std::string& s0,      const std::string& s1 = "",
     const std::string& s2 = "", const std::string& s3 = "",
     const std::string& s4 = "")
  { return at(strings_to_key(s0, s1, s2, s3, s4)); }

  const_reference
  at(const std::string& s0,      const std::string& s1 = "",
     const std::string& s2 = "", const std::string& s3 = "",
     const std::string& s4 = "") const
  { return at(strings_to_key(s0, s1, s2, s3, s4)); }

  reference
  at(int i0, int i1 = no_index_, int i2 = no_index_,
             int i3 = no_index_, int i4 = no_index_)
  { return at(ints_to_key(i0, i1, i2, i3, i4)); }

  const_reference
  at(int i0, int i1 = no_index_, int i2 = no_index_,
             int i3 = no_index_, int i4 = no_index_) const
  { return at(ints_to_key(i0, i1, i2, i3, i4)); }

  reference
  front()
  { return impl_.front(); }

  const_reference
  front() const
  { return impl_.front(); }

  reference
  back()
  { return impl_.back(); }

  const_reference
  back() const
  { return impl_.back(); }

  // iterators
  iterator
  begin()
  { return impl_.begin(); }

  const_iterator
  begin() const
  { return impl_.begin(); }

  const_iterator
  cbegin() const
  { return impl_.begin(); }

  iterator
  end()
  { return impl_.end(); }

  const_iterator
  end() const
  { return impl_.end(); }

  const_iterator
  cend() const
  { return impl_.end(); }

  reverse_iterator
  rbegin()
  { return impl_.rbegin(); }

  const_reverse_iterator
  rbegin() const
  { return impl_.rbegin(); }

  const_reverse_iterator
  crbegin() const
  { return impl_.rbegin(); }

  reverse_iterator
  rend()
  { return impl_.rend(); }

  const_reverse_iterator
  rend() const
  { return impl_.rend(); }

  const_reverse_iterator
  crend() const
  { return impl_.rend(); }

  // lookup
  iterator
  find(const key_type& key)
  { return std::find_if(begin(), end(), key_matches(key)); }

  const_iterator
  find(const key_type& key) const
  { return std::find_if(begin(), end(), key_matches(key)); }

  template<class InputIterator> static InputIterator
  find(InputIterator first, InputIterator last, const key_type& key)
  { return std::find_if(first, last, key_matches(key)); }

  iterator
  find_block_def()
  {
    return std::find_if(begin(), end(),
      std::mem_fun_ref(&value_type::is_block_def));
  }

  const_iterator
  find_block_def() const
  {
    return std::find_if(begin(), end(),
      std::mem_fun_ref(&value_type::is_block_def));
  }

  // introspection
  size_type
  count(const key_type& key) const
  { return std::count_if(begin(), end(), key_matches(key)); }

  // capacity
  size_type
  size() const
  { return impl_.size(); }

  size_type
  data_size() const
  {
    return std::count_if(begin(), end(),
      std::mem_fun_ref(&value_type::is_data_line));
  }

  size_type
  max_size() const
  { return impl_.max_size(); }

  bool
  empty() const
  { return impl_.empty(); }

  // modifiers
  void
  push_back(const value_type& line)
  { impl_.push_back(line); }

  void
  push_back(const std::string& line)
  { impl_.push_back(value_type(line)); }

  void
  pop_back()
  { impl_.pop_back(); }

  iterator
  insert(iterator position, const value_type& line)
  { return impl_.insert(position, line); }

  template<class InputIterator> void
  insert(iterator position, InputIterator first, InputIterator last)
  { impl_.insert(position, first, last); }

  iterator
  erase(iterator position)
  { return impl_.erase(position); }

  iterator
  erase(iterator first, iterator last)
  { return impl_.erase(first, last); }

  iterator
  erase_first(const key_type& key)
  {
    iterator line = find(key);
    return (line != end()) ? erase(line) : line;
  }

  iterator
  erase_last(const key_type& key)
  {
    reverse_iterator line = find(rbegin(), rend(), key);
    return (line != rend()) ? erase((++line).base()) : end();
  }

  size_type
  erase(const key_type& key)
  {
    const key_matches pred(key);
    size_type erased_count = 0;

    for (iterator line = begin(); line != end();)
    {
      if (pred(*line))
      {
        line = erase(line);
        ++erased_count;
      }
      else ++line;
    }
    return erased_count;
  }

  void
  swap(Block& block)
  {
    name_.swap(block.name_);
    impl_.swap(block.impl_);
  }

  void
  clear()
  {
    name_.clear();
    impl_.clear();
  }

  void
  reformat()
  { std::for_each(begin(), end(), std::mem_fun_ref(&value_type::reformat)); }

  void
  comment()
  { std::for_each(begin(), end(), std::mem_fun_ref(&value_type::comment)); }

  void
  uncomment()
  { std::for_each(begin(), end(), std::mem_fun_ref(&value_type::uncomment)); }

  struct key_matches : public std::unary_function<value_type, bool>
  {
    explicit
    key_matches(const key_type& key) : key_(key) {}

    bool
    operator()(const value_type& line) const
    {
      return (key_.empty() || key_.size() > line.size()) ? false :
        std::equal(key_.begin(), key_.end(), line.begin(), parts_equal);
    }

    void
    set_key(const key_type& key)
    { key_ = key; }

  private:
    static bool
    parts_equal(const std::string& key_part, const std::string& field)
    { return (key_part == "(any)") || boost::iequals(key_part, field); }

  private:
    key_type key_;
  };

private:
  template<class Container> static key_type
  cont_to_key(const Container& cont)
  {
    key_type key;
    key.reserve(cont.size());
    std::string (*to_string)(const typename Container::value_type&) =
      boost::lexical_cast<std::string, typename Container::value_type>;
    std::transform(cont.begin(), cont.end(), std::back_inserter(key),
      to_string);
    return key;
  }

  static key_type
  strings_to_key(const std::string& s0, const std::string& s1,
                 const std::string& s2, const std::string& s3,
                 const std::string& s4)
  {
    key_type key;
    key.reserve(5);
    if (s0.empty()) return key; key.push_back(s0);
    if (s1.empty()) return key; key.push_back(s1);
    if (s2.empty()) return key; key.push_back(s2);
    if (s3.empty()) return key; key.push_back(s3);
    if (s4.empty()) return key; key.push_back(s4);
    return key;
  }

  static key_type
  ints_to_key(int i0, int i1, int i2, int i3, int i4)
  {
    key_type key;
    key.reserve(5);
    if (i0 == no_index_) return key; key.push_back(to_string(i0));
    if (i1 == no_index_) return key; key.push_back(to_string(i1));
    if (i2 == no_index_) return key; key.push_back(to_string(i2));
    if (i3 == no_index_) return key; key.push_back(to_string(i3));
    if (i4 == no_index_) return key; key.push_back(to_string(i4));
    return key;
  }

private:
  std::string name_;
  impl_type impl_;
  static const int no_index_ = -32768;
};


class Coll
{
private:
  typedef std::deque<Block> impl_type;

public:
  typedef std::string                       key_type;
  typedef Block                             value_type;
  typedef Block&                            reference;
  typedef const Block&                      const_reference;
  typedef impl_type::iterator               iterator;
  typedef impl_type::const_iterator         const_iterator;
  typedef impl_type::reverse_iterator       reverse_iterator;
  typedef impl_type::const_reverse_iterator const_reverse_iterator;
  typedef impl_type::pointer                pointer;
  typedef impl_type::const_pointer          const_pointer;
  typedef impl_type::difference_type        difference_type;
  typedef impl_type::size_type              size_type;

  // NOTE: The compiler-generated copy constructor and assignment
  //   operator for this class are just fine, so we don't need to
  //   write our own.

  Coll() : impl_() {}

  explicit
  Coll(std::istream& is) : impl_()
  { read(is); }

  static Coll
  from_str(const std::string& coll)
  {
    std::istringstream input(coll);
    return Coll(input);
  }

  Coll&
  read(std::istream& is)
  {
    std::string line_str;
    Line line;

    const size_type orig_size = size();
    pointer block = push_back_named_block("");

    while (std::getline(is, line_str))
    {
      if (detail::is_all_whitespace(line_str)) continue;

      line.str(line_str);
      if (line.is_block_def()) block = push_back_named_block(line[1]);
      block->push_back(line);
    }

    erase_if_empty("", orig_size);
    return *this;
  }

  Coll&
  str(const std::string& coll)
  {
    std::istringstream input(coll);
    clear();
    read(input);
    return *this;
  }

  std::string
  str() const
  {
    std::ostringstream output;
    output << *this;
    return output.str();
  }

  // element access
  reference
  operator[](const key_type& blockName)
  {
    iterator block = find(blockName);
    if (block != end()) return *block;

    push_back(value_type(blockName));
    return back();
  }

  reference
  at(const key_type& blockName)
  {
    iterator block = find(blockName);
    if (block != end()) return *block;

    throw std::out_of_range("SLHAea::Coll::at(‘" + blockName + "’)");
  }

  const_reference
  at(const key_type& blockName) const
  {
    const_iterator block = find(blockName);
    if (block != end()) return *block;

    throw std::out_of_range("SLHAea::Coll::at(‘" + blockName + "’)");
  }

  reference
  at(const value_type::key_type& key)
  {
    iterator block = find(key);
    if (block != end()) return *block;

    throw std::out_of_range(
      "SLHAea::Coll::at(‘" + boost::join(key, ",") + "’)");
  }

  const_reference
  at(const value_type::key_type& key) const
  {
    const_iterator block = find(key);
    if (block != end()) return *block;

    throw std::out_of_range(
      "SLHAea::Coll::at(‘" + boost::join(key, ",") + "’)");
  }

  reference
  front()
  { return impl_.front(); }

  const_reference
  front() const
  { return impl_.front(); }

  reference
  back()
  { return impl_.back(); }

  const_reference
  back() const
  { return impl_.back(); }

  // (nested) element access via Key
  reference
  block(const Key& key);

  const_reference
  block(const Key& key) const;

  Block::reference
  line(const Key& key);

  Block::const_reference
  line(const Key& key) const;

  Line::reference
  field(const Key& key);

  Line::const_reference
  field(const Key& key) const;

  // iterators
  iterator
  begin()
  { return impl_.begin(); }

  const_iterator
  begin() const
  { return impl_.begin(); }

  const_iterator
  cbegin() const
  { return impl_.begin(); }

  iterator
  end()
  { return impl_.end(); }

  const_iterator
  end() const
  { return impl_.end(); }

  const_iterator
  cend() const
  { return impl_.end(); }

  reverse_iterator
  rbegin()
  { return impl_.rbegin(); }

  const_reverse_iterator
  rbegin() const
  { return impl_.rbegin(); }

  const_reverse_iterator
  crbegin() const
  { return impl_.rbegin(); }

  reverse_iterator
  rend()
  { return impl_.rend(); }

  const_reverse_iterator
  rend() const
  { return impl_.rend(); }

  const_reverse_iterator
  crend() const
  { return impl_.rend(); }

  // lookup
  iterator
  find(const key_type& blockName)
  { return std::find_if(begin(), end(), key_matches(blockName)); }

  const_iterator
  find(const key_type& blockName) const
  { return std::find_if(begin(), end(), key_matches(blockName)); }

  template<class InputIterator> static InputIterator
  find(InputIterator first, InputIterator last, const key_type& blockName)
  { return std::find_if(first, last, key_matches(blockName)); }

  iterator
  find(const value_type::key_type& key)
  { return std::find_if(begin(), end(), key_matches_block_def(key)); }

  const_iterator
  find(const value_type::key_type& key) const
  { return std::find_if(begin(), end(), key_matches_block_def(key)); }

  template<class InputIterator> static InputIterator
  find(InputIterator first, InputIterator last,
       const value_type::key_type& key)
  { return std::find_if(first, last, key_matches_block_def(key)); }

  // introspection
  size_type
  count(const key_type& blockName) const
  { return std::count_if(begin(), end(), key_matches(blockName)); }

  // capacity
  size_type
  size() const
  { return impl_.size(); }

  size_type
  max_size() const
  { return impl_.max_size(); }

  bool
  empty() const
  { return impl_.empty(); }

  // modifiers
  void
  push_back(const value_type& block)
  { impl_.push_back(block); }

  void
  push_back(const std::string& blockString)
  {
    value_type block;
    block.str(blockString);
    impl_.push_back(block);
  }

  void
  push_front(const value_type& block)
  { impl_.push_front(block); }

  void
  push_front(const std::string& blockString)
  {
    value_type block;
    block.str(blockString);
    impl_.push_front(block);
  }

  void
  pop_back()
  { impl_.pop_back(); }

  iterator
  insert(iterator position, const value_type& block)
  { return impl_.insert(position, block); }

  template<class InputIterator> void
  insert(iterator position, InputIterator first, InputIterator last)
  { impl_.insert(position, first, last); }

  iterator
  erase(iterator position)
  { return impl_.erase(position); }

  iterator
  erase(iterator first, iterator last)
  { return impl_.erase(first, last); }

  iterator
  erase_first(const key_type& blockName)
  {
    iterator block = find(blockName);
    return (block != end()) ? erase(block) : block;
  }

  iterator
  erase_last(const key_type& blockName)
  {
    reverse_iterator block = find(rbegin(), rend(), blockName);
    return (block != rend()) ? erase((++block).base()) : end();
  }

  size_type
  erase(const key_type& blockName)
  {
    const key_matches pred(blockName);
    size_type erased_count = 0;

    for (iterator block = begin(); block != end();)
    {
      if (pred(*block))
      {
        block = erase(block);
        ++erased_count;
      }
      else ++block;
    }
    return erased_count;
  }

  void
  swap(Coll& coll)
  { impl_.swap(coll.impl_); }

  void
  clear()
  { impl_.clear(); }

  void
  reformat()
  { std::for_each(begin(), end(), std::mem_fun_ref(&value_type::reformat)); }

  void
  comment()
  { std::for_each(begin(), end(), std::mem_fun_ref(&value_type::comment)); }

  void
  uncomment()
  { std::for_each(begin(), end(), std::mem_fun_ref(&value_type::uncomment)); }

  struct key_matches : public std::unary_function<value_type, bool>
  {
    explicit
    key_matches(const key_type& blockName) : name_(blockName) {}

    bool
    operator()(const value_type& block) const
    { return boost::iequals(name_, block.name()); }

    void
    set_key(const key_type& blockName)
    { name_ = blockName; }

  private:
    key_type name_;
  };

  struct key_matches_block_def : public std::unary_function<value_type, bool>
  {
    explicit
    key_matches_block_def(const value_type::key_type& key)
      : key_matches_(key) {}

    bool
    operator()(const value_type& block) const
    {
      value_type::const_iterator block_def = block.find_block_def();
      return (block_def == block.end()) ? false : key_matches_(*block_def);
    }

    void
    set_key(const value_type::key_type& key)
    { key_matches_.set_key(key); }

  private:
    value_type::key_matches key_matches_;
  };

private:
  pointer
  push_back_named_block(const key_type& blockName)
  {
    push_back(value_type(blockName));
    return &back();
  }

  iterator
  erase_if_empty(const key_type& blockName, const size_type& offset = 0)
  {
    iterator block = find(begin() + offset, end(), blockName);
    return (block != end() && block->empty()) ? erase(block) : block;
  }

private:
  impl_type impl_;
};


struct Key
{
public:
  Coll::key_type block;

  Block::key_type line;

  Line::size_type field;

  Key(const Coll::key_type& _block,
      const Block::key_type& _line,
      const Line::size_type& _field)
    : block(_block), line(_line), field(_field) {}

  Key(const std::string& keyString)
  { str(keyString); }

  Key(const char* keyString)
  { str(keyString); }

  Key&
  str(const std::string& keyString)
  {
    std::vector<std::string> keys;
    boost::split(keys, keyString, boost::is_any_of(";"));

    if (keys.size() != 3)
    { throw std::invalid_argument("SLHAea::Key::str(‘" + keyString + "’)"); }

    block = keys[0];
    line.clear();
    boost::split(line, keys[1], boost::is_any_of(","));
    field = to<Line::size_type>(keys[2]);

    return *this;
  }

  std::string
  str() const
  {
    std::ostringstream output;
    output << block << ";" << boost::join(line, ",") << ";" << field;
    return output.str();
  }
};


inline Coll::reference
Coll::block(const Key& key)
{ return at(key.block); }

inline Coll::const_reference
Coll::block(const Key& key) const
{ return at(key.block); }

inline Block::reference
Coll::line(const Key& key)
{ return block(key).at(key.line); }

inline Block::const_reference
Coll::line(const Key& key) const
{ return block(key).at(key.line); }

inline Line::reference
Coll::field(const Key& key)
{ return line(key).at(key.field); }

inline Line::const_reference
Coll::field(const Key& key) const
{ return line(key).at(key.field); }


// stream operators
inline std::istream&
operator>>(std::istream& is, Block& block)
{
  block.read(is);
  return is;
}

inline std::istream&
operator>>(std::istream& is, Coll& coll)
{
  coll.read(is);
  return is;
}

inline std::ostream&
operator<<(std::ostream& os, const Line& line)
{ return os << line.str(); }

inline std::ostream&
operator<<(std::ostream& os, const Block& block)
{
  std::copy(block.begin(), block.end(),
            std::ostream_iterator<Block::value_type>(os, "\n"));
  return os;
}

inline std::ostream&
operator<<(std::ostream& os, const Coll& coll)
{
  std::copy(coll.begin(), coll.end(),
            std::ostream_iterator<Coll::value_type>(os));
  return os;
}

inline std::ostream&
operator<<(std::ostream& os, const Key& key)
{ return os << key.str(); }


// relational operators for Line
inline bool
operator==(const Line& a, const Line& b)
{
  return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin())
    && a.str() == b.str();
}

inline bool
operator<(const Line& a, const Line& b)
{
  const bool a_is_block_def = a.is_block_def();

  return (a_is_block_def != b.is_block_def()) ? a_is_block_def :
    std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
}

inline bool
operator!=(const Line& a, const Line& b)
{ return !(a == b); }

inline bool
operator>(const Line& a, const Line& b)
{ return b < a; }

inline bool
operator<=(const Line& a, const Line& b)
{ return !(b < a); }

inline bool
operator>=(const Line& a, const Line& b)
{ return !(a < b); }


// relational operators for Block
inline bool
operator==(const Block& a, const Block& b)
{
  return a.size() == b.size() && a.name() == b.name()
    && std::equal(a.begin(), a.end(), b.begin());
}

inline bool
operator<(const Block& a, const Block& b)
{
  return (a.name() != b.name()) ? a.name() < b.name() :
    std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
}

inline bool
operator!=(const Block& a, const Block& b)
{ return !(a == b); }

inline bool
operator>(const Block& a, const Block& b)
{ return b < a; }

inline bool
operator<=(const Block& a, const Block& b)
{ return !(b < a); }

inline bool
operator>=(const Block& a, const Block& b)
{ return !(a < b); }


// relational operators for Coll
inline bool
operator==(const Coll& a, const Coll& b)
{ return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin()); }

inline bool
operator<(const Coll& a, const Coll& b)
{
  return std::lexicographical_compare(a.begin(), a.end(),
                                      b.begin(), b.end());
}

inline bool
operator!=(const Coll& a, const Coll& b)
{ return !(a == b); }

inline bool
operator>(const Coll& a, const Coll& b)
{ return b < a; }

inline bool
operator<=(const Coll& a, const Coll& b)
{ return !(b < a); }

inline bool
operator>=(const Coll& a, const Coll& b)
{ return !(a < b); }

} // namespace SLHAea

#endif // SLHAEA_H