vasculature.h

#pragma once
 
#include <memory>  // std::shared_ptr
#include <string>  // std::string
#include <vector>  // std::vector
 
#include <morphio/types.h>
#include <morphio/vasc/iterators.hpp>
#include <morphio/vasc/properties.h>
 
namespace morphio {
namespace vasculature {
 
using graph_iterator = graph_iterator_t<Section, Vasculature>;
 
class Vasculature
{
  public:
    explicit Vasculature(const std::string& source);
 
    Vasculature(Vasculature&&) = default;
    virtual ~Vasculature() = default;
 
    Vasculature& operator=(const Vasculature&) = default;
    Vasculature& operator=(Vasculature&&) = default;
 
    std::vector<Section> sections() const;
 
    Section section(uint32_t id) const;
 
    const std::vector<uint32_t> sectionOffsets() const noexcept;
 
    inline const Points& points() const noexcept;
 
    inline const std::vector<morphio::floatType>& diameters() const noexcept;
 
    inline const std::vector<property::SectionType::Type>& sectionTypes() const noexcept;
 
    const std::vector<morphio::vasculature::property::Connection::Type>& sectionConnectivity() const
        noexcept;
 
 
    graph_iterator begin() const;
    graph_iterator end() const;
 
  private:
    std::shared_ptr<property::Properties> properties_;
 
    template <typename Property>
    inline const std::vector<typename Property::Type>& get() const noexcept;
};
 
template <typename Property>
inline const std::vector<typename Property::Type>& Vasculature::get() const noexcept {
    return properties_->get<Property>();
}
 
inline const Points& Vasculature::points() const noexcept {
    return get<property::Point>();
}
 
inline const std::vector<morphio::floatType>& Vasculature::diameters() const noexcept {
    return get<property::Diameter>();
}
 
inline const std::vector<property::SectionType::Type>& Vasculature::sectionTypes() const noexcept {
    return get<property::SectionType>();
}
 
}  // namespace vasculature
}  // namespace morphio