mesh_connectivity.h

Go to the documentation of this file.

#ifndef MESH_CONNECTIVITY_H
#define MESH_CONNECTIVITY_H
 
#include "bitrl/bitrl_consts.h"
#include "bitrl/bitrl_types.h"
 
#include <iterator>
#include <ostream>
#include <vector>
 
namespace bitrl
{
namespace utils
{
namespace geom
{
 
class MeshConnectivity
{
 
  public:
    typedef std::vector<uint_t>::iterator connectivity_iterator;
    typedef std::vector<uint_t>::const_iterator const_connectivity_iterator;
 
    MeshConnectivity();
 
    explicit MeshConnectivity(uint_t n);
 
    explicit MeshConnectivity(const std::vector<uint_t> &conn);
 
    MeshConnectivity(const MeshConnectivity &o);
 
    MeshConnectivity &operator=(const MeshConnectivity &o);
 
    void assign_connections(const std::vector<uint_t> &connections);
 
    void set_connectivity_size(uint_t size) { connections_.resize(size); }
 
    void set_connection(uint_t i, uint_t connection_idx) { connections_[i] = connection_idx; }
 
    void invalidate_connections();
 
    void clear_connections() { connections_.clear(); }
 
    void push_back(uint_t idx) { connections_.push_back(idx); }
 
    uint_t operator[](uint_t i) const { return connections_[i]; }
 
    uint_t size() const { return connections_.size(); }
 
    bool empty() const { return connections_.empty(); }
 
    uint_t connection_idx(uint_t i) const;
 
    std::ostream &print_connectivity_info(std::ostream &o) const;
 
    connectivity_iterator connectivity_begin() { return connections_.begin(); }
    connectivity_iterator connectivity_end() { return connections_.end(); }
 
    const_connectivity_iterator connectivity_begin() const { return connections_.begin(); }
    const_connectivity_iterator connectivity_end() const { return connections_.end(); }
 
  private:
    std::vector<uint_t> connections_;
};
 
inline MeshConnectivity::MeshConnectivity() : connections_() {}
 
inline MeshConnectivity::MeshConnectivity(uint_t n) : connections_(n, bitrl::consts::INVALID_ID) {}
 
inline MeshConnectivity::MeshConnectivity(const std::vector<uint_t> &conn) : connections_(conn) {}
 
inline MeshConnectivity::MeshConnectivity(const MeshConnectivity &o) : connections_(o.connections_)
{
}
inline MeshConnectivity &MeshConnectivity::operator=(const MeshConnectivity &o)
{
 
    if (this == &o)
    {
        return *this;
    }
 
    connections_.assign(o.connections_.begin(), o.connections_.end());
    return *this;
}
 
inline void MeshConnectivity::assign_connections(const std::vector<uint_t> &connections)
{
 
    connections_.assign(connections.begin(), connections.end());
}
 
inline std::ostream &MeshConnectivity::print_connectivity_info(std::ostream &out) const
{
    std::copy(connections_.begin(), connections_.end(), std::ostream_iterator<uint_t>(out, "\n"));
    return out;
}
 
inline uint_t MeshConnectivity::connection_idx(uint_t i) const
{
    if (i >= connections_.size())
    {
        throw std::logic_error("Invalid connection index: " + std::to_string(i) + " not in [0, " +
                               std::to_string(connections_.size()));
    }
 
    return connections_[i];
}
 
inline std::ostream &operator<<(std::ostream &out, const MeshConnectivity &connectivity)
{
 
    return connectivity.print_connectivity_info(out);
}
 
} // namespace geom
 
} // namespace utils
} // namespace bitrl
#endif