includeLinks/CornerTag.hpp

Go to the documentation of this file.

/* ***************************************************************** 
    MESQUITE -- The Mesh Quality Improvement Toolkit

    Copyright 2005 Lawrence Livermore National Laboratory.  Under 
    the terms of Contract B545069 with the University of Wisconsin -- 
    Madison, Lawrence Livermore National Laboratory retains certain
    rights in this software.

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library 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.

    You should have received a copy of the GNU Lesser General Public License 
    (lgpl.txt) along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    kraftche@cae.wisc.edu    

  ***************************************************************** */

#ifndef MSQ_CORNER_TAG_HPP
#define MSQ_CORNER_TAG_HPP

#ifdef MSQ_USE_OLD_STD_HEADERS
#  include <vector.h>
#else
#  include <vector>
#endif
#include <string>
#include <assert.h>

#include "MeshInterface.hpp"
#include "MsqError.hpp"

namespace Mesquite {

class PatchData;

class CornerTagHandles
{
public:
  CornerTagHandles( const char* tag_name, 
                    Mesh::TagType type, 
                    unsigned tag_len ) 
    : tagName( tag_name ), 
      tagType(type), 
      tagLen(tag_len) 
    {}
  
  TagHandle get_handle( Mesh* mesh, unsigned num_corners, MsqError& err );
  
  void save_load_tags( bool load, PatchData* pd, size_t elem_index, void* data, size_t tag_byes, MsqError& err );

  static Mesh* get_current_mesh( PatchData* pd );
  
  static size_t size( Mesh::TagType type );
  
  static int num_corners( PatchData* pd, int elem_index );

private:

  const msq_std::string tagName;
  const Mesh::TagType tagType;
  const unsigned tagLen;

  msq_std::vector<TagHandle> cornerHandles;
};


template <typename T> class CornerTag 
{
  public:
  
    CornerTag( const char* name, Mesh::TagType type = Mesh::BYTE);
    
    ~CornerTag();
    
    inline void clear( );

    inline const T* get_element_corner_tags( PatchData* pd, int elem_idx, MsqError& err );
    
    inline void set_element_corner_tags( PatchData* pd, int elem_idx, const T* data, MsqError& err );
      
  private:

    CornerTagHandles tagHandles;
    msq_std::vector<T*> tagData; //< Cached tag data for all elems of patch
};


template <typename T>
CornerTag<T>::CornerTag( const char* tag_name, Mesh::TagType type )
 : tagHandles( tag_name, type, sizeof(T) / CornerTagHandles::size(type) )
{
    // We're going to assume this for all tag read/writes,
    // so make sure its true now.
  assert( (sizeof(T) % CornerTagHandles::size(type)) == 0 );
}

template <typename T>
CornerTag<T>::~CornerTag()
{
  clear();
}

template <typename T>
void CornerTag<T>::clear()
{
  for (typename msq_std::vector<T*>::iterator i = tagData.begin(); i != tagData.end(); ++i)
    delete [] *i;
  tagData.clear();
}

template <typename T>
const T* CornerTag<T>::get_element_corner_tags( PatchData* pd, 
                                                int elem_index, 
                                                MsqError& err )
{
  if (tagData.size() <= (unsigned)elem_index)
    tagData.resize( elem_index+1, 0 );
  
  int num_corners = tagHandles.num_corners( pd, elem_index );
  if (!tagData[elem_index]) {
    tagData[elem_index] = new T[num_corners];
    tagHandles.save_load_tags( true, pd, elem_index, tagData[elem_index], sizeof(T), err );
    MSQ_ERRZERO(err);
  }
  
  return tagData[elem_index];
}

template <typename T>
void CornerTag<T>::set_element_corner_tags( PatchData* pd, 
                                            int elem_index, 
                                            const T* data,
                                            MsqError& err )
{
  if (tagData.size() <= (unsigned)elem_index)
    tagData.resize( elem_index+1, 0 );
  
  int num_corners = tagHandles.num_corners( pd, elem_index );
  if (!tagData[elem_index]) 
    tagData[elem_index] = new T[num_corners];
  memcpy( tagData[elem_index], data, num_corners * sizeof(T) );
    
  tagHandles.save_load_tags( false, pd, elem_index, (void*)data, sizeof(T), err );
  MSQ_CHKERR(err);
}
  

} // namespace Mesquite

#endif