collection.h

/* Copyright (c) 2013-2023, EPFL/Blue Brain Project
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
 
#include <memory>
#include <string>
 
#include <morphio/morphology.h>
#include <morphio/mut/morphology.h>
 
namespace morphio {
 
class CollectionImpl;
 
template <class M>
class LoadUnordered;
 
template <class T, class U = void>
struct enable_if_immutable: public std::enable_if<std::is_same<T, Morphology>::value, U> {};
 
template <class T, class U = void>
struct enable_if_mutable: public std::enable_if<std::is_same<T, mut::Morphology>::value, U> {};
 
class Collection
{
  public:
    Collection(std::shared_ptr<CollectionImpl> collection);
 
    Collection(std::string collection_path,
               std::vector<std::string> extensions =
                   std::vector<std::string>{".h5", ".H5", ".asc", ".ASC", ".swc", ".SWC"});
 
    template <class M>
    typename enable_if_mutable<M, M>::type load(
        const std::string& morph_name,
        unsigned int options = NO_MODIFIER,
        std::shared_ptr<WarningHandler> warning_handler = nullptr) const;
 
    template <class M>
    typename enable_if_immutable<M, M>::type load(
        const std::string& morph_name,
        unsigned int options = NO_MODIFIER,
        std::shared_ptr<WarningHandler> warning_handler = nullptr) const;
 
    template <class M>
    LoadUnordered<M> load_unordered(
        std::vector<std::string> morphology_names,
        unsigned int options = NO_MODIFIER,
        std::shared_ptr<WarningHandler> warning_handler = nullptr) const;
 
    std::vector<size_t> argsort(const std::vector<std::string>& morphology_names) const;
 
    void close();
 
  private:
    std::shared_ptr<CollectionImpl> _collection;
};
 
class LoadUnorderedImpl;
 
template <class M>
class LoadUnordered
{
  protected:
    class Iterator
    {
      public:
        Iterator(std::shared_ptr<LoadUnorderedImpl> load_unordered_impl, size_t k);
 
        template <class U = M>
        typename enable_if_immutable<U, std::pair<size_t, M>>::type operator*() const;
 
        template <class U = M>
        typename enable_if_mutable<U, std::pair<size_t, M>>::type operator*() const;
 
        Iterator& operator++();
        Iterator operator++(int);
 
        bool operator==(const Iterator& other) const;
        bool operator!=(const Iterator& other) const;
 
      private:
        size_t _k;
        std::shared_ptr<LoadUnorderedImpl> _load_unordered_impl;
    };
 
  public:
    LoadUnordered(std::shared_ptr<LoadUnorderedImpl> load_unordered_impl);
 
    Iterator begin() const;
    Iterator end() const;
 
  protected:
    std::shared_ptr<LoadUnorderedImpl> _load_unordered_impl;
};
 
extern template class LoadUnordered<Morphology>;
extern template class LoadUnordered<mut::Morphology>;
 
extern template class LoadUnordered<Morphology>::Iterator;
extern template class LoadUnordered<mut::Morphology>::Iterator;
 
extern template typename enable_if_immutable<Morphology, std::pair<size_t, Morphology>>::type
    LoadUnordered<Morphology>::Iterator::operator*<Morphology>() const;
 
extern template
    typename enable_if_mutable<mut::Morphology, std::pair<size_t, mut::Morphology>>::type
        LoadUnordered<mut::Morphology>::Iterator::operator*<mut::Morphology>() const;
 
extern template typename enable_if_mutable<mut::Morphology, mut::Morphology>::type
Collection::load<mut::Morphology>(const std::string& morph_name,
                                  unsigned int options,
                                  std::shared_ptr<WarningHandler> warning_handler) const;
 
extern template typename enable_if_immutable<Morphology, Morphology>::type
Collection::load<Morphology>(const std::string& morph_name,
                             unsigned int options,
                             std::shared_ptr<WarningHandler> warning_handler) const;
 
extern template LoadUnordered<Morphology> Collection::load_unordered<Morphology>(
    std::vector<std::string> morphology_names,
    unsigned int options,
    std::shared_ptr<WarningHandler> warning_handler) const;
 
extern template LoadUnordered<mut::Morphology> Collection::load_unordered<mut::Morphology>(
    std::vector<std::string> morphology_names,
    unsigned int options,
    std::shared_ptr<WarningHandler> warning_handler) const;
 
}  // namespace morphio