LabeledAxisAccessor.h

// Copyright 2024, UChicago Argonne, LLC
// All Rights Reserved
// Software Name: NEML2 -- the New Engineering material Model Library, version 2
// By: Argonne National Laboratory
// OPEN SOURCE LICENSE (MIT)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
 
#pragma once
 
#include <vector>
#include <iosfwd>
#include <string>
 
namespace neml2
{
// Reserved subaxis names
inline const std::string STATE = "state";
inline const std::string OLD_STATE = "old_state";
inline const std::string FORCES = "forces";
inline const std::string OLD_FORCES = "old_forces";
inline const std::string RESIDUAL = "residual";
inline const std::string PARAMETERS = "parameters";
 
// Reserved subaxis names
std::vector<std::string> reserved_subaxis_names();

class LabeledAxisAccessor
{
public:
  LabeledAxisAccessor() = default;
 
  template <typename... S>
  LabeledAxisAccessor(const char * name, S &&... names)
  {
    validate_item_name(name);
    _item_names.emplace_back(name);
 
    (validate_item_name(names), ...);
    (_item_names.emplace_back(std::forward<S>(names)), ...);
  }
 
  template <typename... S>
  LabeledAxisAccessor(const std::string & name, S &&... names)
  {
    validate_item_name(name);
    _item_names.emplace_back(name);
 
    (validate_item_name(names), ...);
    (_item_names.emplace_back(std::forward<S>(names)), ...);
  }
 
  template <typename Container,
            typename = typename std::enable_if_t<
                !std::is_convertible_v<Container, std::string> &&
                std::is_convertible_v<typename std::iterator_traits<
                                          decltype(std::declval<Container>().begin())>::value_type,
                                      std::string> &&
                std::is_convertible_v<typename std::iterator_traits<
                                          decltype(std::declval<Container>().end())>::value_type,
                                      std::string>>>
  LabeledAxisAccessor(const Container & c)
  {
    _item_names = std::vector<std::string>(c.begin(), c.end());
    for (const auto & name : _item_names)
      validate_item_name(name);
  }
 
  using iterator = std::vector<std::string>::iterator;
  using const_iterator = std::vector<std::string>::const_iterator;

  iterator begin() { return iterator(_item_names.begin()); }
  iterator end() { return iterator(_item_names.end()); }
  const_iterator begin() const { return const_iterator(_item_names.begin()); }
  const_iterator end() const { return const_iterator(_item_names.end()); }
 
  explicit operator std::vector<std::string>() const;
 
  const std::vector<std::string> & vec() const { return _item_names; }
 
  std::string str() const;
 
  bool empty() const;
 
  std::size_t size() const;
 
  const std::string & operator[](std::size_t i) const;

  LabeledAxisAccessor with_suffix(const std::string & suffix) const;

  LabeledAxisAccessor append(const LabeledAxisAccessor & other) const;

  LabeledAxisAccessor prepend(const LabeledAxisAccessor & other) const;

  LabeledAxisAccessor slice(std::size_t N) const;

  LabeledAxisAccessor slice(std::size_t N, std::size_t M) const;

  LabeledAxisAccessor remount(const LabeledAxisAccessor & other, int64_t n = 1) const;

  bool start_with(const LabeledAxisAccessor & other) const;

  bool is_state() const;
  bool is_old_state() const;
  bool is_force() const;
  bool is_old_force() const;
  bool is_residual() const;
  bool is_parameter() const;

  LabeledAxisAccessor current() const;

  LabeledAxisAccessor old() const;
 
private:
  void validate_item_name(const std::string &) const;
 
  std::vector<std::string> _item_names;
};

bool operator==(const LabeledAxisAccessor & a, const LabeledAxisAccessor & b);

bool operator!=(const LabeledAxisAccessor & a, const LabeledAxisAccessor & b);

bool operator<(const LabeledAxisAccessor & a, const LabeledAxisAccessor & b);

std::ostream & operator<<(std::ostream & os, const LabeledAxisAccessor & accessor);
 
using VariableName = LabeledAxisAccessor;
using SubaxisName = LabeledAxisAccessor;
 
} // namespace neml2