FieldWrapper.h

/* Copyright 2017 Kristofer Björnson
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef COM_DAFER45_TBTK_FIELD_WRAPPER
#define COM_DAFER45_TBTK_FIELD_WRAPPER

#include "TBTK/Field.h"

#include <initializer_list>

namespace TBTK{

class FieldWrapper{
public:
    enum class DataType{
        ComplexDouble
    };

    enum class ArgumentType{
        Double
    };

    template<typename DataType, typename ArgumentType>
    FieldWrapper(Field<DataType, ArgumentType> &field);

    DataType getDataType() const;

    ArgumentType getArgumentType() const;

    template<typename Data, typename Argument>
    Data operator()(std::initializer_list<Argument> arguments) const;

    template<typename Data, typename Argument>
    bool getIsCompact() const;

    template<typename Data, typename Argument>
    const std::vector<Argument>& getCoordinates() const;
//  const std::vector<double>& getCoordinates() const;

    template<typename Data, typename Argument>
    Argument getExtent() const;
//  double getExtent() const;
private:
    void *field;

    DataType dataType;

    ArgumentType argumentType;
};

template<>
inline FieldWrapper::FieldWrapper(Field<std::complex<double>, double> &field){
    this->field = &field;
    dataType = DataType::ComplexDouble;
    argumentType = ArgumentType::Double;
}

inline FieldWrapper::DataType FieldWrapper::getDataType() const{
    return dataType;
}

inline FieldWrapper::ArgumentType FieldWrapper::getArgumentType() const{
    return argumentType;
}

template<>
inline std::complex<double> FieldWrapper::operator()<std::complex<double>, double>(
    std::initializer_list<double> arguments
) const{
    return ((Field<std::complex<double>, double>*)field)->operator()(arguments);
}

template<>
inline bool FieldWrapper::getIsCompact<std::complex<double>, double>() const{
    return ((Field<std::complex<double>, double>*)field)->getIsCompact();
}

template<>
inline const std::vector<double>& FieldWrapper::getCoordinates<std::complex<double>, double>() const{
    return ((Field<std::complex<double>, double>*)field)->getCoordinates();
}

template<>
inline double FieldWrapper::getExtent<std::complex<double>, double>() const{
    return ((Field<std::complex<double>, double>*)field)->getExtent();
}

};  //End namespace TBTK

#endif