Attribute.h

Go to the documentation of this file.

/* *******************************************************************
 * Rocstar Simulation Suite                                          *
 * Copyright@2015, Illinois Rocstar LLC. All rights reserved.        *
 *                                                                   *
 * Illinois Rocstar LLC                                              *
 * Champaign, IL                                                     *
 * www.illinoisrocstar.com                                           *
 * sales@illinoisrocstar.com                                         *
 *                                                                   *
 * License: See LICENSE file in top level of distribution package or *
 * http://opensource.org/licenses/NCSA                               *
 *********************************************************************/
/* *******************************************************************
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,   *
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   *
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          *
 * NONINFRINGEMENT.  IN NO EVENT SHALL THE CONTRIBUTORS OR           *
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER       *
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,   *
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE    *
 * USE OR OTHER DEALINGS WITH THE SOFTWARE.                          *
 *********************************************************************/
// $Id: Attribute.h,v 1.18 2008/12/06 08:43:24 mtcampbe Exp $

/* Author: Xiangmin Jiao */

#ifndef __ROCCOM_ATTRIBUTE_H__
#define __ROCCOM_ATTRIBUTE_H__

#include <string>
#include "roccom_exception.h"

COM_BEGIN_NAME_SPACE

class Pane;
class Window;

enum COM_Keywords { COM_NC, COM_NC1, COM_NC2, COM_NC3, COM_CONN, 
                    COM_MESH, COM_PCONN, COM_RIDGES, COM_RIDGES1, COM_RIDGES2,
                    COM_PMESH, COM_ATTS, COM_ALL, COM_NUM_KEYWORDS};

class Attribute {
public:
  typedef unsigned char     Shorter_size; 
  typedef unsigned int      Size;         

  Attribute()
    : _pane(NULL), _parent(NULL), _id(-1), _loc(0), _ncomp(0), _type(0), 
      _nitems(-1), _ngitems(0), _gap(0), _status(STATUS_NOT_INITIALIZED), 
      _ptr(NULL), _strd(0), _nbytes_strd(0), _cap(0) {}
  
protected:
  Attribute( Pane *pane, int i) 
    : _pane(pane), _parent(NULL), _name( _keywords[i]), _id(i), 
      _loc(_keylocs[i]), _ncomp(_keysizes[i]), _type(_keytypes[i]), 
      _unit( i<=COM_NC3?"m":""), _nitems(0), _ngitems(0), _gap(0),
      _status(STATUS_NOT_INITIALIZED), _ptr(NULL), _strd(0), 
      _nbytes_strd(0), _cap(0) {}
public:  
  Attribute( Pane *pane, const std::string &name, int id,
             Shorter_size loc, int type, const int ncomp, 
             const std::string &unit)
    : _pane(pane), _parent(NULL), _name( name), _id(id), _loc(loc), 
      _ncomp(ncomp), _type(type), _unit(unit), _nitems(-1), _ngitems(0),
      _gap(0), _status(STATUS_NOT_INITIALIZED), _ptr(0), _strd(0), 
      _nbytes_strd(0), _cap(0) {}

  Attribute( Pane *pane, Attribute *parent, 
             const std::string &name, int id);

  ~Attribute() { 
    if (!_parent) deallocate(); 
    _pane=NULL; _parent=NULL; _id=-1; _loc=0; _ncomp=0; _type=0; 
    _nitems=-1, _ngitems=0; _status=STATUS_NOT_INITIALIZED; _ptr=NULL; 
    _strd=0; _nbytes_strd=0; _cap=0;
  }
  //\}

  const std::string &name()  const { return _name; }

  std::string fullname() const;

  int id()  const { return _id; }

  Attribute *parent()  { return _parent;  }
  const Attribute *parent() const { return _parent; }

  Attribute *root()  { 
    Attribute *a=this;
    while ( a->_parent) a=a->_parent;
    return a;
  }
  const Attribute *root() const { 
    const Attribute *a=this;
    while ( a->_parent) a=a->_parent;
    return a;
  }
  //\}

  const void *pointer()   const { return _status?_ptr:root()->_ptr; }
  void       *pointer() throw(COM_exception) { 
    if ( is_const()) throw COM_exception( COM_ERR_ATTRIBUTE_CONST);
    return _status?_ptr:root()->_ptr; 
  }

  const void *get_addr( int i, int j=0) const throw(COM_exception);

  void *get_addr( int i, int j=0) throw(COM_exception) {
    if ( is_const()) throw COM_exception( COM_ERR_ATTRIBUTE_CONST);
    return (void*)(((const Attribute*)this)->get_addr(i,j));
  }
  //\}

  const Pane   *pane()  const { return _pane; }
  Pane         *pane()        { return _pane; }

  const Window *window()  const;
  Window       *window();

  Shorter_size  location()  const { return _loc; }
  bool is_windowed()      const { return _loc == 'w'; }
  bool is_panel()         const { return _loc == 'p'; }
  bool is_elemental()     const { return _loc == 'e'; }
  bool is_nodal()         const { return _loc == 'n'; }

  COM_Type    data_type() const { return _type; }

  const std::string &unit() const  { return _unit; }
  
  int         size_of_components() const { return _ncomp; }

  int         size_of_items() const;

  int         maxsize_of_items() const;

  int         size_of_ghost_items() const;

  int         maxsize_of_ghost_items() const;

  int        size_of_real_items() const;

  int         maxsize_of_real_items() const;

  bool        empty()     const  { return root()->_nitems<= 0; }

  int         capacity() const { return _status?_cap:root()->_cap; }

  int         stride()    const  { return _status?_strd:root()->_strd; }

  int         stride_in_bytes() const 
  { return _status?_nbytes_strd:root()->_nbytes_strd; }

  int status() const 
  { if ( _parent) return STATUS_USE; else return _status; }

  bool initialized() const { return _status||root()->_status; }

  bool size_set() const;

  bool allocated() const { return _status==STATUS_ALLOCATED; }

  bool is_const() const { return root()->_status==STATUS_SET_CONST; }

  //  a pane/node/element are not stored in consecutive memory space.
  bool   is_staggered()   const { return stride()!=size_of_components(); }

  static int get_sizeof( COM_Type type, int count=1);

  static bool compatible_types( COM_Type t1, COM_Type t2);

  static bool is_digit( char c) { return c>='0' && c<='9'; }
  //\}

  void set_size( int nitems, int ngitems=0) throw(COM_exception);

  void *allocate( int strd, int cap, bool force) throw(COM_exception);

  int deallocate() throw(COM_exception);

  enum Copy_dir { COPY_IN, COPY_OUT };
  // Copy n _ncomp-vectors from "buf" to the array if direction is COPY_IN
  // or copy to "buf" if direction is COPY_OUT.
  void copy_array( void *buf, int strd, int nitem,
                   int offset=0, int direction=COPY_IN) throw(COM_exception);

  // Append n _ncomp-vectors from "from" to the array.
  void append_array( const void *from, int strd, int nitem) throw(COM_exception);

protected:
  void set_pointer( void *p, int strd, int cap, 
                    int offset, bool is_const) throw(COM_exception);
    
  void inherit( Attribute *a, bool clone, bool withghost, int depth=0) throw(COM_exception);

protected:
  Pane        *_pane;       
  Attribute   *_parent;     

  std::string  _name;       
  int          _id;         
  Shorter_size _loc;        

  int          _ncomp;      
  COM_Type     _type;       
  std::string  _unit;       

  int          _nitems;     
  int          _ngitems;    
  int          _gap;        

  enum { STATUS_NOT_INITIALIZED=0, STATUS_SET=1, STATUS_SET_CONST=2,
         STATUS_USE=3, STATUS_ALLOCATED=4 };
  Shorter_size _status;     

  void        *_ptr;          
  int          _strd;         
  int          _nbytes_strd;  
  int          _cap;          

  static const char     *_keywords[COM_NUM_KEYWORDS]; 
  static const char      _keylocs[COM_NUM_KEYWORDS];  
  static const COM_Type  _keytypes[COM_NUM_KEYWORDS]; 
  static const int       _keysizes[COM_NUM_KEYWORDS]; 

private:
  Attribute( const Attribute &a);
  Attribute &operator=( const Attribute&);
};

COM_END_NAME_SPACE

#endif