externalFunctionUserData.hpp

/*
 * CoDiPack, a Code Differentiation Package
 *
 * Copyright (C) 2015-2024 Chair for Scientific Computing (SciComp), University of Kaiserslautern-Landau
 * Homepage: http://www.scicomp.uni-kl.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://www.scicomp.uni-kl.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 <vector>
 
#include "../../config.h"
#include "../../misc/macros.hpp"
 
namespace codi {
 
  struct ExternalFunctionUserData {
    private:
 
      struct DataItemBase {
        public:
          void* data;
 
          virtual ~DataItemBase() {}
 
          virtual DataItemBase* clone() = 0;
      };
 
      template<typename T_Type>
      struct DataItem : public DataItemBase {
        public:
          using Type = CODI_DD(T_Type, CODI_ANY);
 
          explicit DataItem(Type const& value) {
            data = (void*)new Type(value);
          }
 
          ~DataItem() {
            Type* pointer = (Type*)data;
            delete pointer;
          }
 
          DataItemBase* clone() {
            return new DataItem<Type>(*((Type*)data));
          }
      };
 
      template<typename Type>
      struct DataArray : public DataItemBase {
        private:
          int size;
 
        public:
          DataArray(Type const* value, int size) {
            data = (void*)new Type[size];
            this->size = size;
            std::copy(value, &value[size], (Type*)data);
          }
 
          ~DataArray() {
            Type* pointer = (Type*)data;
            delete[] pointer;
          }
 
          DataItemBase* clone() {
            return new DataArray<Type>(*((Type*)data), size);
          }
      };
 
      std::vector<DataItemBase*> store;
 
      size_t storePos;
 
    public:
 
      ExternalFunctionUserData() : storePos(0) {}
 
      ExternalFunctionUserData(ExternalFunctionUserData const& other) {
        copyAll(other, *this);
      }
 
      ~ExternalFunctionUserData() {
        clear();
      }
 
      ExternalFunctionUserData& operator=(ExternalFunctionUserData const& other) {
        this->clear();
        copyAll(other, *this);
 
        return *this;
      }
 
      void clear() {
        for (size_t i = 0; i < store.size(); ++i) {
          delete store[i];
        }
        store.clear();
      }
 
      template<typename Type>
      size_t addData(Type const& value) {
        store.push_back(new DataItem<Type>(value));
        return store.size() - 1;
      }
 
      template<typename Type>
      size_t addData(Type const* value, int const size) {
        store.push_back(new DataArray<Type>(value, size));
        return store.size() - 1;
      }
 
      /*******************************************************************************/
 
      template<typename Type>
      void getData(Type& value) {
        getData<Type>(&value, 1);
      }
 
      template<typename Type>
      Type const& getData() {
        Type* data = nextStore<Type>();
        return *data;
      }
 
      template<typename Type>
      Type& getDataRef() {
        Type* data = nextStore<Type>();
        return *data;
      }
 
      template<typename Type>
      void getData(Type* value, int const size) {
        Type* convPointer = nextStore<Type>();
 
        std::copy(convPointer, &convPointer[size], value);
      }
 
      template<typename Type>
      Type const* getDataArray() {
        Type* data = nextStore<Type>();
        return *data;
      }
 
      void resetPos() {
        storePos = 0;
      }
 
 
      /*******************************************************************************/
 
      template<typename Type>
      void getDataByIndex(Type& value, size_t pos) {
        getDataByIndex<Type>(&value, 1, pos);
      }
 
      template<typename Type>
      Type const& getDataByIndex(size_t pos) {
        Type* data = getStore<Type>(pos);
        return *data;
      }
 
      template<typename Type>
      Type& getDataRefByIndex(size_t pos) {
        Type* data = getStore<Type>(pos);
        return *data;
      }
 
      template<typename Type>
      void getDataByIndex(Type* value, int const size, size_t pos) {
        Type* convPointer = getStore<Type>(pos);
 
        std::copy(convPointer, &convPointer[size], value);
      }
 
      template<typename Type>
      Type const* getDataArrayByIndex() {
        Type* data = nextStore<Type>();
        return *data;
      }
 
 
    private:
 
      static void copyAll(ExternalFunctionUserData const& from, ExternalFunctionUserData& to) {
        for (size_t i = 0; i < from.store.size(); ++i) {
          to.store.push_back(from.store[i]->clone());
        }
        to.storePos = from.storePos;
      }
 
      template<typename Type>
      Type* getStore(size_t pos) {
        return (Type*)store[pos]->data;
      }
 
      template<typename Type>
      Type* nextStore() {
        Type* pointer = getStore<Type>(storePos);
        storePos += 1;
        if (storePos >= store.size()) {
          storePos = 0;
        }
 
        return pointer;
      }
  };
}