compositevolume.h

#ifndef CTL_COMPOSITEVOLUME_H
#define CTL_COMPOSITEVOLUME_H

#include "abstractdynamicvolumedata.h"

namespace CTL {
class CompositeVolume
{
public:
    using SubVolPtr = CopyableUniquePtr<SpectralVolumeData>;

    // variadic ctor for several volume types
    template <class Volume, class... Volumes>
    explicit CompositeVolume(Volume&& volume, Volumes&&... otherVolumes);

    // defaulted special member functions
    CompositeVolume() = default;
    CompositeVolume(const CompositeVolume& volume) = default;
    CompositeVolume(CompositeVolume&& volume) = default;
    CompositeVolume& operator=(const CompositeVolume& volume) = default;
    CompositeVolume& operator=(CompositeVolume&& volume) = default;
    ~CompositeVolume() = default;

    // getter methods
    const std::vector<SubVolPtr>& data() const;
    std::vector<SubVolPtr>& data();
    bool isEmpty() const;
    std::unique_ptr<SpectralVolumeData> muVolume(uint volIdx, float centerEnergy,
                                                 float binWidth) const;
    uint nbSubVolumes() const;
    const SpectralVolumeData& subVolume(uint volIdx) const;
    SpectralVolumeData& subVolume(uint volIdx);

    // other methods
    void addSubVolume(SpectralVolumeData volume);
    void addSubVolume(std::unique_ptr<SpectralVolumeData> volume);
    void addSubVolume(const AbstractDynamicVolumeData& volume);
    void addSubVolume(CompositeVolume&& volume);
    void addSubVolume(const CompositeVolume& volume);
    template <class Volume, class... Volumes>
    void addSubVolumes(Volume&& volume, Volumes&&... otherVolumes);

private:
    void addSubVolumes() const {}
    template <class Volume, class... Volumes>
    static uint getTotalNbSubVolumes(const Volume& volume, const Volumes&... otherVolumes);
    template <class Volume>
    static constexpr uint getTotalNbSubVolumes(const Volume& volume);
    static uint getTotalNbSubVolumes(const CompositeVolume& volume);

    std::vector<SubVolPtr> _subVolumes; 
};

template<class Volume, class... Volumes>
CompositeVolume::CompositeVolume(Volume&& volume, Volumes&&... otherVolumes)
{
    addSubVolumes(std::forward<Volume>(volume), std::forward<Volumes>(otherVolumes)...);
}

template <class Volume, class... Volumes>
void CompositeVolume::addSubVolumes(Volume&& volume, Volumes&&... otherVolumes)
{
    _subVolumes.reserve(getTotalNbSubVolumes(*this, volume, otherVolumes...));

    addSubVolume(std::forward<Volume>(volume));
    addSubVolumes(std::forward<Volumes>(otherVolumes)...);
}

template <class Volume, class... Volumes>
uint CompositeVolume::getTotalNbSubVolumes(const Volume& volume, const Volumes&... otherVolumes)
{
    return getTotalNbSubVolumes(volume) + getTotalNbSubVolumes(otherVolumes...);
}

template <class Volume>
constexpr uint CompositeVolume::getTotalNbSubVolumes(const Volume&)
{
    return 1u;
}

inline uint CompositeVolume::getTotalNbSubVolumes(const CompositeVolume& volume)
{
    return volume.nbSubVolumes();
}

} // namespace CTL

#endif // CTL_COMPOSITEVOLUME_H