src/Mesh/MeshImplTags.hpp

Go to the documentation of this file.

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

    Copyright 2004 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 MESQUITE_MESH_IMPL_TAGS_HPP
#define MSSQUITE_MESH_IMPL_TAGS_HPP

#include "Mesquite.hpp"
#include "MeshInterface.hpp"

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

namespace Mesquite {

  struct TagDescription {
      // The VTK attribute type the data was read from, or NONE if not VTK data.
      // This property is kept only so that when a vtk file is read and subseqquently
      // written, it can be preserved for other potential readers that actually care
      // about it.
    enum VtkType { NONE = 0, SCALAR, COLOR, VECTOR, NORMAL, TEXTURE, TENSOR, FIELD };

    msq_std::string name; 
    Mesh::TagType type;   
    VtkType vtkType;      
    size_t size;          

    inline TagDescription( msq_std::string n, Mesh::TagType t, VtkType v, size_t s )
      : name(n), type(t), vtkType(v), size(s) {}

    inline TagDescription( )
      : type(Mesh::BYTE), vtkType(NONE), size(0) {}

    inline bool operator==(const TagDescription& o) const
      { return name == o.name && type == o.type && vtkType == o.vtkType && size == o.size; }
    inline bool operator!=(const TagDescription& o) const
      { return name != o.name || type != o.type || vtkType != o.vtkType || size != o.size; }
  };

class MeshImplTags {
  public:

  ~MeshImplTags() { clear(); }

  struct TagData  {

    const TagDescription desc;

    void* elementData;

    size_t elementCount;

    void* vertexData;
    
    size_t vertexCount;

    void* defaultValue;

    inline TagData( const msq_std::string& name, 
             Mesh::TagType type, unsigned length,
             void* default_val = 0,
             TagDescription::VtkType vtk_type = TagDescription::NONE )
      : desc(name, type, vtk_type, length*size_from_tag_type(type)),
        elementData(0), elementCount(0),
        vertexData(0), vertexCount(0), 
        defaultValue(default_val) {}

    inline TagData( const TagDescription& descr )
      : desc(descr), elementData(0), elementCount(0),
        vertexData(0), vertexCount(0),
        defaultValue(0) {}

    ~TagData();
  };
  
  static size_t size_from_tag_type( Mesh::TagType type );

  void clear();

  size_t handle( const msq_std::string& name, MsqError& err ) const;
  
  const TagDescription& properties( size_t tag_handle, MsqError& err ) const;
  
  size_t create( const msq_std::string& name,
                 Mesh::TagType type,
                 unsigned length,
                 const void* defval,
                 MsqError& err );
                 
  size_t create( const TagDescription& desc, MsqError& err );

  void destroy( size_t tag_index, MsqError& err );
  
  void set_element_data( size_t tag_handle,
                         size_t num_indices,
                         const size_t* elem_indices,
                         const void* tag_data,
                         MsqError& err );
  
  void set_vertex_data( size_t tag_handle,
                        size_t num_indices,
                        const size_t* elem_indices,
                        const void* tag_data,
                        MsqError& err );

  void get_element_data( size_t tag_handle,
                         size_t num_indices,
                         const size_t* elem_indices,
                         void* tag_data,
                         MsqError& err ) const;
  
  void get_vertex_data( size_t tag_handle,
                        size_t num_indices,
                        const size_t* elem_indices,
                        void* tag_data,
                        MsqError& err ) const;
  
  class TagIterator 
  {
    public:
      TagIterator( MeshImplTags* d, size_t i ) : tags(d), index(i) {}
      size_t operator*() const  { return index+1; }
      TagIterator operator++();
      TagIterator operator--();
      TagIterator operator++(int);
      TagIterator operator--(int);
      bool operator==(TagIterator other) const { return index == other.index; }
      bool operator!=(TagIterator other) const { return index != other.index; }
    private:
      MeshImplTags* tags;
      size_t index;
  };
  TagIterator tag_begin();
  TagIterator tag_end()   { return TagIterator(this,tagList.size()); }

  bool tag_has_vertex_data( size_t index, MsqError& err ) ;
  bool tag_has_element_data( size_t index, MsqError& err ) ;
  
  private:

  friend class MeshImplTags::TagIterator;  
  
    msq_std::vector<TagData*> tagList;
}; // class MeshImplTags

} // namespace Mesquite

#endif