section.h

#pragma once
 
#include <memory>  // std::shared_ptr
 
#include <morphio/morphology.h>
#include <morphio/properties.h>
#include <morphio/section_base.h>
#include <morphio/section_iterators.hpp>
#include <morphio/types.h>
 
namespace morphio {
 
using upstream_iterator = upstream_iterator_t<Section>;
using breadth_iterator = breadth_iterator_t<Section, Morphology>;
using depth_iterator = depth_iterator_t<Section, Morphology>;
 
class Section: public SectionBase<Section>
{
    using SectionId = Property::Section;
    using PointAttribute = Property::Point;
 
  public:
    depth_iterator depth_begin() const {
        return depth_iterator(*this);
    }
    depth_iterator depth_end() const {
        return depth_iterator();
    }
 
    breadth_iterator breadth_begin() const {
        return breadth_iterator(*this);
    }
    breadth_iterator breadth_end() const {
        return breadth_iterator();
    }
 
    upstream_iterator upstream_begin() const {
        return upstream_iterator(*this);
    }
    upstream_iterator upstream_end() const {
        return upstream_iterator();
    }
 
    range<const Point> points() const {
        return get<Property::Point>();
    }
 
    range<const floatType> diameters() const {
        return get<Property::Diameter>();
    }
 
    range<const floatType> perimeters() const {
        return get<Property::Perimeter>();
    }
 
    SectionType type() const {
        return properties_->get<Property::SectionType>()[id_];
    }
 
    bool isHeterogeneous(bool downstream = true) const;
 
    bool hasSameShape(const Section& other) const noexcept;
 
    friend class mut::Section;
    friend Section Morphology::section(uint32_t) const;
    friend class SectionBase<Section>;
 
  protected:
    Section(uint32_t id, const std::shared_ptr<Property::Properties>& properties)
        : SectionBase(id, properties) {}
};
 
}  // namespace morphio
 
std::ostream& operator<<(std::ostream& os, const morphio::Section& section);