attachment_pipe.h

Go to the documentation of this file.

/*
 * Copyright (c) 2009-2015:  G-CSC, Goethe University Frankfurt
 * Author: Sebastian Reiter
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */
 
#ifndef __UTIL__ATTACHMENT_PIPE__
#define __UTIL__ATTACHMENT_PIPE__
 
#include <list>
#include <vector>
#include <stack>
#include <cassert>
#include "common/static_assert.h"
#include "common/types.h"
#include "common/util/uid.h"
#include "common/util/hash.h"
#include "common/ug_config.h"
#include "page_container.h"
 
namespace ug
{
 
// PREDECLARATIONS
class IAttachment;
class IAttachmentDataContainer;
 
 
// CONSTANTS
enum ATTACHMENT_CONSTANTS
{
  INVALID_ATTACHMENT_INDEX = 0xFFFFFFFF
};
enum ATTACHMENT_CONSTANTS {…};
 
 
//  IAttachedDataContainer
 
class UG_API IAttachmentDataContainer
{
  public:
    virtual ~IAttachmentDataContainer()   {}
 
    virtual void resize(size_t iSize) = 0;
    virtual size_t size() = 0;
    virtual void copy_data(size_t indFrom, size_t indTo) = 0;
    virtual void reset_entry(size_t index) = 0;
    
    virtual void copy_to_container(IAttachmentDataContainer* pDestCon,
                     int* indexMap, int num) const = 0;
    
    virtual void defragment(size_t* pNewIndices, size_t numValidElements) = 0;
 
 
    virtual size_t occupied_memory() = 0;
};
class UG_API IAttachmentDataContainer {…};
 
 
template <class TValue>
struct attachment_value_traits{
  typedef TValue&     reference;
  typedef const TValue& const_reference;
};
struct attachment_value_traits {…};
 
template <>
struct attachment_value_traits<bool>{
  typedef std::vector<bool>::reference    reference;
  typedef const std::vector<bool>::reference  const_reference;
};
struct attachment_value_traits<bool> {…};
 
/* THOUGHTS
* AttachmentDataContainer<T> should probably be defined in another header, since it is somehow specialised for libGrid.
* same goes for Attachment<T>
*/
//  AttachedDataContainer
 
template <class T> class UG_API AttachmentDataContainer : public IAttachmentDataContainer
{
  private:
    typedef AttachmentDataContainer<T>  ClassType;
    //typedef PageContainer<T>      DataContainer;
    typedef std::vector<T>        DataContainer;
    typedef typename attachment_value_traits<T>::reference      TRef;
    typedef typename attachment_value_traits<T>::const_reference  TConstRef;
 
  public:
    typedef T ValueType;
 
    AttachmentDataContainer(const T& defaultValue = T())  : m_defaultValue(defaultValue)  {}
 
    virtual ~AttachmentDataContainer()      {m_vData.clear();}
 
    virtual void resize(size_t iSize)
      {
        if(iSize > 0)
          m_vData.resize(iSize, m_defaultValue);
        else
          m_vData.clear();
      }
    virtual void resize(size_t iSize) {…}
 
    virtual size_t size() {return m_vData.size();}
 
    virtual void copy_data(size_t indFrom, size_t indTo)    {m_vData[indTo] = m_vData[indFrom];}
 
    virtual void reset_entry(size_t index)
      {
        m_vData[index] = m_defaultValue;
      }
    virtual void reset_entry(size_t index) {…}
 
    virtual void defragment(size_t* pNewIndices, size_t numValidElements)
      {
        size_t numOldElems = size();
        DataContainer vDataOld = m_vData;
        m_vData.resize(numValidElements);
        for(size_t i = 0; i < numOldElems; ++i)
        {
          size_t nInd = pNewIndices[i];
          if(nInd != INVALID_ATTACHMENT_INDEX)
            m_vData[nInd] = vDataOld[i];
        }
      }
    virtual void defragment(size_t* pNewIndices, size_t numValidElements) {…}
  
    virtual void copy_to_container(IAttachmentDataContainer* pDestCon,
                    int* indexMap, int num) const
      {
        ClassType* destConT = dynamic_cast<ClassType*>(pDestCon);
        assert(destConT && "Type of pDestBuf has to be the same as the"
            "type of this buffer");
 
        if(!destConT)
          return;
 
        DataContainer& dest = destConT->get_data_container();
        for(int i = 0; i < num; ++i)
          dest[i] = m_vData[indexMap[i]];
      }
    virtual void copy_to_container(IAttachmentDataContainer* pDestCon, {…}
 
 
    virtual size_t occupied_memory()
    {
      return m_vData.capacity() * sizeof(T);
    }
    virtual size_t occupied_memory() {…}
 
    inline TConstRef get_elem(size_t index) const   {return m_vData[index];}
    inline TRef get_elem(size_t index)          {return m_vData[index];}
    inline TConstRef operator[] (size_t index) const  {return m_vData[index];}
    inline TRef operator[] (size_t index)       {return m_vData[index];}
 
    void swap(AttachmentDataContainer<T>& container)  {m_vData.swap(container.m_vData);}
 
  protected:
    DataContainer& get_data_container()     {return m_vData;}
    //inline const T* get_ptr() const     {return &m_vData.front();}
    //inline T* get_ptr()           {return &m_vData.front();}
    
  protected:
    DataContainer m_vData;
    T       m_defaultValue;
};
template <class T> class UG_API AttachmentDataContainer : public IAttachmentDataContainer {…};
 
//  IAttachment
 
class UG_API IAttachment : public UID
{
  public:
    IAttachment() : m_name("undefined")   {}
    IAttachment(const char* name) : m_name(name)
      {assert(m_name);}
    IAttachment(const char* name) : m_name(name) {…}
 
    virtual ~IAttachment()  {}
    virtual IAttachment* clone() = 0;
    virtual IAttachmentDataContainer* create_container() = 0;
    virtual bool default_pass_on_behaviour() const = 0;
 
    const char* get_name()  {return m_name;}    
 
  protected:
    const char* m_name; //only for debug
};
 
//  Attachment
 
template <class T> class UG_API Attachment : public IAttachment
{
  public:
    typedef AttachmentDataContainer<T>  ContainerType;
    typedef T             ValueType;
 
    Attachment() : IAttachment(), m_passOnBehaviour(false)    {}
    Attachment(bool passOnBehaviour) : IAttachment(), m_passOnBehaviour(passOnBehaviour)    {}
    Attachment(const char* name) : IAttachment(name), m_passOnBehaviour(false)      {}
    Attachment(const char* name, bool passOnBehaviour) : IAttachment(name), m_passOnBehaviour(passOnBehaviour)  {}
 
    virtual ~Attachment() {}
    virtual IAttachment* clone()              {IAttachment* pA = new Attachment<T>; *pA = *this; return pA;}
    virtual IAttachmentDataContainer* create_container()  {return new ContainerType;}
    virtual bool default_pass_on_behaviour() const      {return m_passOnBehaviour;}
    IAttachmentDataContainer* create_container(const T& defaultValue) {return new ContainerType(defaultValue);}
 
  protected:
    bool m_passOnBehaviour;
};
template <class T> class UG_API Attachment : public IAttachment {…};
 
//  AttachmentEntry
struct AttachmentEntry
{
  AttachmentEntry() : m_pAttachment(NULL), m_pContainer(NULL), m_userData(0)  {}
  AttachmentEntry(IAttachment* pAttachment, IAttachmentDataContainer* pContainer, uint userData = 0) :
      m_pAttachment(pAttachment), m_pContainer(pContainer), m_userData(userData)  {}
  AttachmentEntry(IAttachment* pAttachment, IAttachmentDataContainer* pContainer, uint userData = 0) : {…}
 
  IAttachment*        m_pAttachment;
  IAttachmentDataContainer* m_pContainer;
  uint            m_userData;
};
struct AttachmentEntry {…};
 
 
 
template<class TElem, class TElemHandler>
class attachment_traits
{
  public:
    typedef TElem&    ElemRef;
    typedef void*   ElemPtr;
    typedef const void* ConstElemPtr;
    typedef void*   ElemHandlerPtr;
    typedef const void* ConstElemHandlerPtr;
 
    typedef void    element_iterator;
 
    static inline element_iterator elements_begin(ElemHandlerPtr pHandler)          {}
    static inline element_iterator elements_end(ElemHandlerPtr pHandler)          {}
    static inline uint get_data_index(ElemHandlerPtr pHandler, ConstElemPtr elem)     {return INVALID_ATTACHMENT_INDEX;/*STATIC_ASSERT(0, INVALID_ATTACHMENT_TRAITS);*/}
    static inline void set_data_index(ElemHandlerPtr pHandler, ElemPtr elem, size_t index)  {/*STATIC_ASSERT(0, INVALID_ATTACHMENT_TRAITS);*/}
};
class attachment_traits {…};
 
//  AttachmentPipe
 
template<class TElem, class TElemHandler>
class UG_API AttachmentPipe
{
  public:
    typedef TElem               element;
    typedef TElemHandler            ElementHandler;
    typedef std::list<AttachmentEntry>      AttachmentEntryContainer;
    typedef AttachmentEntryContainer::iterator  AttachmentEntryIterator;
    typedef AttachmentEntryContainer::const_iterator  ConstAttachmentEntryIterator;
    typedef Hash<uint, AttachmentEntryIterator>   AttachmentEntryIteratorHash;
    typedef attachment_traits<TElem, TElemHandler>  atraits;
 
  public:
    AttachmentPipe();
    AttachmentPipe(typename atraits::ElemHandlerPtr pHandler);
    ~AttachmentPipe();
    
    inline typename atraits::ElemHandlerPtr get_elem_handler()    {return m_pHandler;}
    
    void clear();
    void clear_elements();
    void clear_attachments();
 
 
    void reserve(size_t numElems);
 
 
    void register_element(TElem elem);
 
 
    void unregister_element(const TElem& elem);
 
    void defragment();
 
    template <class TAttachment>
    void attach(TAttachment& attachment,
          const typename TAttachment::ValueType& defaultValue,
          uint options);
 
    void attach(IAttachment& attachment, uint options = 0);
    void detach(IAttachment& attachment);
 
    bool has_attachment(IAttachment& attachment) const;
 
 
    template <class TAttachment>
    typename TAttachment::ValueType*
    get_data_array(TAttachment& attachment);
    
    IAttachmentDataContainer* get_data_container(IAttachment& attachment) const;
 
    template <class TAttachment>
    typename TAttachment::ContainerType*
    get_data_container(TAttachment& attachment);
    inline ConstAttachmentEntryIterator attachments_begin() const {return m_attachmentEntryContainer.begin();}
    inline ConstAttachmentEntryIterator attachments_end() const   {return m_attachmentEntryContainer.end();}
 
    inline size_t num_elements() const    {return m_numElements;}
 
    inline size_t num_data_entries() const  {return m_numDataEntries;}
 
 
    inline bool is_fragmented() const   {return m_numElements != m_numDataEntries;}
 
    void reset_values(size_t dataIndex);
 
  protected:
    void resize_attachment_containers(size_t newSize);
    void grow_attachment_containers(size_t newMinSize);
    inline size_t get_container_size();
 
  protected:
    typedef std::stack<size_t>    UINTStack;
 
  protected:
    AttachmentEntryContainer  m_attachmentEntryContainer;
    AttachmentEntryIteratorHash m_attachmentEntryIteratorHash;
 
    UINTStack   m_stackFreeEntries; 
 
    size_t      m_numElements;
    size_t      m_numDataEntries;
    size_t      m_containerSize; 
    
    typename atraits::ElemHandlerPtr  m_pHandler;
};
class UG_API AttachmentPipe {…};
 
 
//  AttachmentAccessor
 
template <class TElem, class TAttachment, class TElemHandler>
class UG_API AttachmentAccessor
{
  public:
    typedef TAttachment             attachment;
    typedef TElem               element;
    typedef typename TAttachment::ValueType   ValueType;
    typedef typename TAttachment::ContainerType ContainerType;
    typedef TElemHandler            ElemHandler;
    typedef attachment_traits<TElem, TElemHandler>  atraits;
    typedef AttachmentPipe<TElem, TElemHandler> attachment_pipe;
 
  public:
    AttachmentAccessor();
    AttachmentAccessor(const AttachmentAccessor& aa);
    AttachmentAccessor(AttachmentPipe<TElem, TElemHandler>& attachmentPipe, TAttachment& attachment);
 
    bool access(attachment_pipe& attachmentPipe, TAttachment& attachment);
 
    inline typename attachment_value_traits<ValueType>::reference
    operator[](typename atraits::ConstElemPtr elem)
      {
        assert((attachment_traits<TElem, TElemHandler>::get_data_index(m_pHandler, elem) != INVALID_ATTACHMENT_INDEX) &&
            "ERROR in AttachmentAccessor::operator[]: accessing element with invalid attachment index!");
        assert(m_pContainer && "ERROR in AttachmentAccessor::operator[]: no AttachmentPipe assigned.");
        return m_pContainer->get_elem(attachment_traits<TElem, TElemHandler>::get_data_index(m_pHandler, elem));
      }
    operator[](typename atraits::ConstElemPtr elem) {…}
      
    inline typename attachment_value_traits<ValueType>::const_reference
    operator[](typename atraits::ConstElemPtr elem) const
      {
        assert((attachment_traits<TElem, TElemHandler>::get_data_index(m_pHandler, elem) != INVALID_ATTACHMENT_INDEX) &&
            "ERROR in AttachmentAccessor::operator[]: accessing element with invalid attachment index!");
        assert(m_pContainer && "ERROR in AttachmentAccessor::operator[]: no AttachmentPipe assigned.");
        return m_pContainer->get_elem(attachment_traits<TElem, TElemHandler>::get_data_index(m_pHandler, elem));
      }
    operator[](typename atraits::ConstElemPtr elem) const {…}
      
/*
    inline ValueType&
    operator[](int index)
      {
        assert(m_pContainer && "ERROR in AttachmentAccessor::operator[]: no AttachmentPipe assigned.");
        return m_pContainer->get_elem(index);
      }
*/
    inline bool valid() const
      {return m_pContainer != NULL;}
    inline bool valid() const {…}
 
    inline void invalidate()
      {m_pContainer = NULL;}
    inline void invalidate() {…}
      
    void swap(AttachmentAccessor<TElem, TAttachment, TElemHandler>& acc)
    {
      m_pContainer->swap(*acc.m_pContainer);
    }
    void swap(AttachmentAccessor<TElem, TAttachment, TElemHandler>& acc) {…}
 
 
    ValueType* raw_data()
    {
      if(m_pContainer){
        if(m_pContainer->size() > 0)
          return &(*m_pContainer)[0];
      }
      return NULL;
    }
    ValueType* raw_data() {…}
    
 
    size_t element_data_index(typename atraits::ConstElemPtr elem)
    {
      return attachment_traits<TElem, TElemHandler>::get_data_index(m_pHandler, elem);
    }
    size_t element_data_index(typename atraits::ConstElemPtr elem) {…}
    
  protected:
    ContainerType*  m_pContainer;
    TElemHandler* m_pHandler;
};
class UG_API AttachmentAccessor {…};
 
 
}// end of namespace
 
//  include implementation
#include "attachment_pipe.hpp"
 
#endif
    const char* m_name; //only for debug {…};
class UG_API IAttachment : public UID {…};