position.hpp

/*
 * CoDiPack, a Code Differentiation Package
 *
 * Copyright (C) 2015-2024 Chair for Scientific Computing (SciComp), University of Kaiserslautern-Landau
 * Homepage: http://scicomp.rptu.de
 * Contact:  Prof. Nicolas R. Gauger (codi@scicomp.uni-kl.de)
 *
 * Lead developers: Max Sagebaum, Johannes Blühdorn (SciComp, University of Kaiserslautern-Landau)
 *
 * This file is part of CoDiPack (http://scicomp.rptu.de/software/codi).
 *
 * CoDiPack 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.
 *
 * CoDiPack 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 CoDiPack.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * For other licensing options please contact us.
 *
 * Authors:
 *  - SciComp, University of Kaiserslautern-Landau:
 *    - Max Sagebaum
 *    - Johannes Blühdorn
 *    - Former members:
 *      - Tim Albring
 */
#pragma once
 
#include <cstdlib>
#include <iostream>
 
#include "../../config.h"
#include "../../misc/macros.hpp"
 
namespace codi {
 
  struct EmptyPosition {
    public:
 
      bool operator!=(EmptyPosition const& o) const {
        CODI_UNUSED(o);
        return false;
      }
 
      bool operator==(EmptyPosition const& o) const {
        CODI_UNUSED(o);
        return true;
      }
 
      bool operator<(EmptyPosition const& o) const {
        CODI_UNUSED(o);
        return false;
      }
 
      bool operator<=(EmptyPosition const& o) const {
        CODI_UNUSED(o);
        return true;
      }
 
      bool operator>(EmptyPosition const& o) const {
        CODI_UNUSED(o);
        return false;
      }
 
      bool operator>=(EmptyPosition const& o) const {
        CODI_UNUSED(o);
        return true;
      }
 
      friend std::ostream& operator<<(std::ostream& stream, EmptyPosition const& pos) {
        CODI_UNUSED(pos);
        stream << "[]";
        return stream;
      }
  };
 
  template<typename T_NestedPosition>
  struct ArrayPosition {
    public:
 
      using NestedPosition = CODI_DD(T_NestedPosition, EmptyPosition);  
 
      size_t data;  
 
      NestedPosition inner;  
 
      ArrayPosition() : data(0), inner() {}
 
      ArrayPosition(size_t const& data, NestedPosition const& inner) : data(data), inner(inner) {}
 
      bool operator!=(ArrayPosition const& o) const {
        return data != o.data || this->inner != o.inner;
      }
 
      bool operator==(ArrayPosition const& o) const {
        return data == o.data && this->inner == o.inner;
      }
 
      bool operator<(ArrayPosition const& o) const {
        return data < o.data || (data == o.data && inner < o.inner);
      }
 
      bool operator<=(ArrayPosition const& o) const {
        return data < o.data || (data == o.data && inner <= o.inner);
      }
 
      bool operator>(ArrayPosition const& o) const {
        return o < *this;
      }
 
      bool operator>=(ArrayPosition const& o) const {
        return o <= *this;
      }
 
      friend std::ostream& operator<<(std::ostream& stream, ArrayPosition const& pos) {
        stream << "[" << pos.data << ", " << pos.inner << "]";
        return stream;
      }
  };
 
  template<typename T_NestedPosition>
  struct ChunkPosition : public ArrayPosition<T_NestedPosition> {
    public:
 
      using NestedPosition = CODI_DD(T_NestedPosition, EmptyPosition);  
      using Base = ArrayPosition<NestedPosition>;                       
 
      size_t chunk;  
 
      ChunkPosition() : Base(), chunk(0) {}
 
      ChunkPosition(size_t const& chunk, size_t const& data, NestedPosition const& inner)
          : Base(data, inner), chunk(chunk) {}
 
      bool operator!=(ChunkPosition const& o) const {
        return chunk != o.chunk || Base::operator!=(static_cast<Base const&>(o));
      }
 
      bool operator==(ChunkPosition const& o) const {
        return chunk == o.chunk && Base::operator==(static_cast<Base const&>(o));
      }
 
      bool operator<(ChunkPosition const& o) const {
        return chunk < o.chunk || (chunk == o.chunk && Base::operator<(static_cast<Base const&>(o)));
      }
 
      bool operator<=(ChunkPosition const& o) const {
        return chunk < o.chunk || (chunk == o.chunk && Base::operator<=(static_cast<Base const&>(o)));
      }
 
      bool operator>(ChunkPosition const& o) const {
        return o < *this;
      }
 
      bool operator>=(ChunkPosition const& o) const {
        return o <= *this;
      }
 
      friend std::ostream& operator<<(std::ostream& stream, ChunkPosition const& pos) {
        stream << "[" << pos.chunk << ", " << pos.data << ", " << pos.inner << "]";
        return stream;
      }
  };
}