Program Listing for File Group.hpp

↰ Return to documentation for file (include/nix/Group.hpp)

// Copyright (c) 2013, German Neuroinformatics Node (G-Node)
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted under the terms of the BSD License. See
// LICENSE file in the root of the Project.

#ifndef NIX_GROUP_HPP
#define NIX_GROUP_HPP

#include <nix/base/EntityWithSources.hpp>
#include <nix/base/IGroup.hpp>
#include <nix/DataArray.hpp>
#include <nix/DataFrame.hpp>
#include <nix/Platform.hpp>
#include <nix/ObjectType.hpp>
#include <nix/util/util.hpp>


namespace nix {

class NIXAPI Group : public base::EntityWithSources<base::IGroup> {

public:

    Group()
        : EntityWithSources() { }

    Group(const Group &other)
        : EntityWithSources(other.impl()) {
    }

    Group(const std::shared_ptr<base::IGroup> &p_impl)
        : EntityWithSources(p_impl) {
    }

    Group(std::shared_ptr<base::IGroup> &&ptr)
        : EntityWithSources(std::move(ptr)) {
    }

    //--------------------------------------------------
    // Methods concerning data arrays.
    //--------------------------------------------------
    // TODO syntactic sugar for creating dataArrays, tags, multiTags
    bool hasDataArray(const std::string &name_or_id) const {
        return backend()->hasEntity({name_or_id, ObjectType::DataArray});
    }

    bool hasDataArray(const DataArray &data_array) const {
        if (!util::checkEntityInput(data_array, false)) {
            return false;
        }
        return backend()->hasEntity(data_array);
    }

    ndsize_t dataArrayCount() const {
        return backend()->entityCount(ObjectType::DataArray);
    }

    DataArray getDataArray(const std::string &name_or_id) const {
        return backend()->getEntity<base::IDataArray>(name_or_id);
    }

    DataArray getDataArray(size_t index) const {
        if (index >= backend()->entityCount(ObjectType::DataArray)) {
            throw OutOfBounds("No DataArray at given index", index);
        }
        return backend()->getEntity<base::IDataArray>(index);
    }

    void addDataArray(const DataArray &data_array) {
        if (util::checkEntityInput(data_array, true)) {
            backend()->addEntity(data_array);
        }
    }
    void addDataArray(const std::string &name_or_id) {
        backend()->addEntity({name_or_id, ObjectType::DataArray});
    }
    bool removeDataArray(const DataArray &data_array) {
        if (!util::checkEntityInput(data_array, false)) {
            return false;
        }
        return backend()->removeEntity(data_array);
    }
    bool removeDataArray(const std::string &name_or_id) {
        return backend()->removeEntity({name_or_id, ObjectType::DataArray});
    }

    std::vector<DataArray> dataArrays(const util::Filter<DataArray>::type &filter) const;

    std::vector<DataArray> dataArrays() const
    {
        return dataArrays(util::AcceptAll<DataArray>());
    }

    void dataArrays(const std::vector<DataArray> &data_arrays);

    //--------------------------------------------------
    // Methods concerning data frames.
    //--------------------------------------------------
    bool hasDataFrame(const std::string &name_or_id) const {
        return backend()->hasEntity({name_or_id, ObjectType::DataFrame});
    }

    bool hasDataFrame(const DataFrame &data_frame) const {
        if (!util::checkEntityInput(data_frame, false)) {
            return false;
        }
        return backend()->hasEntity(data_frame);
    }

    ndsize_t dataFrameCount() const {
        return backend()->entityCount(ObjectType::DataFrame);
    }

    DataFrame getDataFrame(const std::string &name_or_id) const {
        return backend()->getEntity<base::IDataFrame>(name_or_id);
    }

    DataFrame getDataFrame(ndsize_t index) const {
        if (index >= backend()->entityCount(ObjectType::DataFrame)) {
            throw OutOfBounds("No DataFrame at given index", index);
        }
        return backend()->getEntity<base::IDataFrame>(index);
    }

    void addDataFrame(const DataFrame &data_frame) {
        if (util::checkEntityInput(data_frame, true)) {
            backend()->addEntity(data_frame);
        }
    }
    void addDataFrame(const std::string &name_or_id) {
        backend()->addEntity({name_or_id, ObjectType::DataFrame});
    }
    bool removeDataFrame(const DataFrame &data_frame) {
        if (!util::checkEntityInput(data_frame, false)) {
            return false;
        }
        return backend()->removeEntity(data_frame);
    }
    bool removeDataFrame(const std::string &name_or_id) {
        return backend()->removeEntity({name_or_id, ObjectType::DataFrame});
    }

    std::vector<DataFrame> dataFrames(const util::Filter<DataFrame>::type &filter) const;

    std::vector<DataFrame> dataFrames() const
    {
        return dataFrames(util::AcceptAll<DataFrame>());
    }

    void dataFrames(const std::vector<DataFrame> &data_frames);

    //--------------------------------------------------
    // Methods concerning tags.
    //--------------------------------------------------

    bool hasTag(const std::string &name_or_id) const {
        return backend()->hasEntity({name_or_id, ObjectType::Tag});
    }

    bool hasTag(const Tag &tag) const {
        if (!util::checkEntityInput(tag, false)) {
            return false;
        }
        return backend()->hasEntity(tag);
    }

    ndsize_t tagCount() const {
        return backend()->entityCount(ObjectType::Tag);
    }

    Tag getTag(const std::string &name_or_id) const {
        return backend()->getEntity<base::ITag>(name_or_id);
    }

    Tag getTag(size_t index) const {
        if (index >= backend()->entityCount(ObjectType::Tag)) {
            throw OutOfBounds("No Tag at given index", index);
        }
        return backend()->getEntity<base::ITag>(index);
    }

    void addTag(const Tag &tag) {
        if (util::checkEntityInput(tag, true)) {
            backend()->addEntity(tag);
        }
    }

    void addTag(const std::string &name_or_id) {
        backend()->addEntity({name_or_id, ObjectType::Tag});
    }

    bool removeTag(const Tag &tag) {
          if (!util::checkEntityInput(tag, false)) {
            return false;
        }
        return backend()->removeEntity(tag);
    }

    bool removeTag(const std::string &name_or_id) {
        return backend()->removeEntity({name_or_id, ObjectType::Tag});
    }

    std::vector<Tag> tags(const util::Filter<Tag>::type &filter) const;

    std::vector<Tag> tags() const {
        return tags(util::AcceptAll<Tag>());
    }

    void tags(const std::vector<Tag> &tags);
    //--------------------------------------------------
    // Methods concerning multi tags.
    //--------------------------------------------------

    bool hasMultiTag(const std::string &name_or_id) const {
        return backend()->hasEntity({name_or_id, ObjectType::MultiTag});
    }

    bool hasMultiTag(const MultiTag &tag) const {
        if (!util::checkEntityInput(tag, false)) {
            return false;
        }
        return backend()->hasEntity(tag);
    }


    ndsize_t multiTagCount() const {
        return backend()->entityCount(ObjectType::MultiTag);
    }

    MultiTag getMultiTag(const std::string &name_or_id) const {
        return backend()->getEntity<base::IMultiTag>(name_or_id);
    }

    MultiTag getMultiTag(size_t index) const {
        if (index >= backend()->entityCount(ObjectType::MultiTag)) {
            throw OutOfBounds("No MultiTag at given index", index);
        }
        return backend()->getEntity<base::IMultiTag>(index);
    }

    void addMultiTag(const MultiTag &multi_tag) {
        if (util::checkEntityInput(multi_tag, true)) {
            backend()->addEntity(multi_tag);
        }
    }

    void addMultiTag(const std::string &name_or_id) {
        backend()->addEntity({name_or_id, ObjectType::MultiTag});
    }

    bool removeMultiTag(const MultiTag &multi_tag) {
        if (!util::checkEntityInput(multi_tag, false)) {
            return false;
        }
        return backend()->removeEntity(multi_tag);
    }

    bool removeMultiTag(const std::string &name_or_id) {
        return backend()->removeEntity({name_or_id, ObjectType::MultiTag});
    }

    std::vector<MultiTag> multiTags(const util::Filter<MultiTag>::type &filter) const;

    std::vector<MultiTag> multiTags() const {
        return multiTags(util::AcceptAll<MultiTag>());
    }

    void multiTags(const std::vector<MultiTag> &multi_tags);


    Group &operator=(const none_t &t) {
        ImplContainer::operator=(t);
        return *this;
    }

    Group &operator=(const Group &other)  {
        ImplContainer::operator=(other);
        return *this;
    }

    NIXAPI friend std::ostream &operator<<(std::ostream &out, const Group &ent);

 private:
    template<typename T>
    void replaceEntities(const std::vector<T> &entitties);
};

template<>
struct objectToType<nix::Group> {
    static const bool isValid = true;
    static const ObjectType value = ObjectType::Group;
    typedef nix::base::IGroup backendType;
};

NIXAPI std::ostream &operator<<(std::ostream &out, const Group &ent);

} // namespace nix

#endif //NIX_GROUP_HPP