annotation.h

Go to the documentation of this file.

/*
 *  This file is a part of TiledArray.
 *  Copyright (C) 2015  Virginia Tech
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Justus Calvin
 *  Department of Chemistry, Virginia Tech
 *
 *  tensor.h
 *  Jun 16, 2015
 *
 */
 
#ifndef TILEDARRAY_ANNOTATION_H__INCLUDED
#define TILEDARRAY_ANNOTATION_H__INCLUDED
#include <algorithm>
#include <cstring>
#include <string>
#include "TiledArray/error.h"
 
namespace TiledArray::detail {
 
inline std::string dummy_annotation(unsigned int n_outer_size,
                                    unsigned int n_inner_size = 0) {
  std::ostringstream oss;
  if (n_outer_size > 0) oss << "i0";
  for (unsigned int d = 1; d < n_outer_size; ++d) oss << ",i" << d;
  if (n_inner_size == 0) return oss.str();
  oss << ";i" << n_outer_size;
  for (unsigned int d = 1; d < n_inner_size; ++d)
    oss << ",i" << d + n_outer_size;
  return oss.str();
}
 
inline auto remove_whitespace(std::string s) {
  s.erase(std::remove(s.begin(), s.end(), ' '), s.end());
  return s;
}
 
inline auto tokenize_index(const std::string& s, char delim) {
  if (s.size() == 0) return std::vector<std::string>{""};
  std::vector<std::string> tokens;
  std::stringstream ss(s);
  std::string buffer;
  while (std::getline(ss, buffer, delim))
    tokens.emplace_back(std::move(buffer));
 
  // If the delimiter is the last element, we miss an empty string so add it
  if (s[s.size() - 1] == delim) tokens.push_back(std::string{});
  return tokens;
}
 
inline bool is_valid_index(const std::string& idx) {
  const std::string valid_chars =
      "abcdefghijklmnopqrstuvwxyz"
      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
      "1234567890"
      " _',;";
  // Are valid characters
  for (const auto& c : idx)
    if (valid_chars.find(c) == std::string::npos) return false;
 
  // Is not only whitespace
  auto no_ws = remove_whitespace(idx);
  if (no_ws.size() == 0) return false;
 
  // At most one semicolon
  auto split_on_semicolon = tokenize_index(no_ws, ';');
  if (split_on_semicolon.size() > 2) return false;
 
  for (auto x : split_on_semicolon) {
    auto indices = tokenize_index(x, ',');
    for (const auto& idx : indices)
      if (idx.size() == 0) return false;
  }
 
  return true;
}
 
inline bool is_tot_index(const std::string& idx) {
  if (!is_valid_index(idx)) return false;
  return idx.find(";") != std::string::npos;
}
 
inline auto split_index(const std::string& idx) {
  TA_ASSERT(is_valid_index(idx));
  auto no_ws = remove_whitespace(idx);
  if (!is_tot_index(no_ws)) {
    return std::make_pair(tokenize_index(no_ws, ','),
                          std::vector<std::string>{});
  }
  auto tot_idx = tokenize_index(no_ws, ';');
  return std::make_pair(tokenize_index(tot_idx[0], ','),
                        tokenize_index(tot_idx[1], ','));
}
 
}  // namespace TiledArray::detail
 
#endif  // TILEDARRAY_ANNOTATION_H__INCLUDED