fei_Record.hpp

/*--------------------------------------------------------------------*/
/*    Copyright 2005 Sandia Corporation.                              */
/*    Under the terms of Contract DE-AC04-94AL85000, there is a       */
/*    non-exclusive license for use of this work by or on behalf      */
/*    of the U.S. Government.  Export of this program may require     */
/*    a license from the United States Government.                    */
/*--------------------------------------------------------------------*/
 
#ifndef _fei_Record_hpp_
#define _fei_Record_hpp_
 
#include <fei_macros.hpp>
 
namespace fei {
class FieldMask;

template<typename GlobalIDType>
class Record {
public:
  Record();

  Record(const Record<GlobalIDType>& src)
    : ID_(src.ID_),
      number_(src.number_),
      fieldMask_(src.fieldMask_),
      offsetIntoEqnNumbers_(src.offsetIntoEqnNumbers_),
      ownerProc_(src.ownerProc_),
      isInLocalSubdomain_(src.isInLocalSubdomain_),
      hasSlaveDof_(src.hasSlaveDof_)
    {}

  virtual ~Record();

  void setID(const GlobalIDType& ID)
  {
    ID_ = ID;
  }

  GlobalIDType getID() const
  {
    return(ID_);
  }

  void setNumber(const GlobalIDType& num)
  {
    number_ = num;
  }

  GlobalIDType getNumber() const
  {
    return(number_);
  }

  bool operator==(const Record<GlobalIDType>& rcd) const
  {
    return( ID_ == rcd.ID_ );
  }

  bool operator!=(const Record<GlobalIDType>& rcd) const
  {
    return( ID_ != rcd.ID_ );
  }

  bool operator<(const Record<GlobalIDType>& rcd) const
  {
    return( ID_ < rcd.ID_ );
  }

  bool operator>(const Record<GlobalIDType>& rcd) const
  {
    return( ID_ > rcd.ID_ );
  }

  void setOwnerProc(int owner)
  {
    ownerProc_ = owner;
  }

  int getOwnerProc() const
  {
    return(ownerProc_);
  }

  void setFieldMask(fei::FieldMask* fm)
  {
    fieldMask_ = fm;
  }

  fei::FieldMask* getFieldMask()
  {
    return( fieldMask_ );
  }

  const fei::FieldMask* getFieldMask() const
  {
    return( fieldMask_ );
  }

  void setOffsetIntoEqnNumbers(int offset)
  {
    offsetIntoEqnNumbers_ = offset;
  }

  int getOffsetIntoEqnNumbers() const
  {
    return(offsetIntoEqnNumbers_);
  }
 
  bool hasSlaveDof() const
  { return( hasSlaveDof_ ); }
 
  void hasSlaveDof(bool flag)
  { hasSlaveDof_ = flag; }
 
  Record<GlobalIDType>& operator=(const Record<GlobalIDType>& src)
  {
    ID_ = src.ID_;
    number_ = src.number_;
    fieldMask_ = src.fieldMask_;
    offsetIntoEqnNumbers_ = src.offsetIntoEqnNumbers_;
    ownerProc_ = src.ownerProc_;
    isInLocalSubdomain_ = src.isInLocalSubdomain_;
    hasSlaveDof_ = src.hasSlaveDof_;
    return *this;
  }
 
private:
 
  GlobalIDType ID_;
  GlobalIDType number_;
 
  fei::FieldMask* fieldMask_;
 
  int offsetIntoEqnNumbers_;
 
  int ownerProc_;
 
public:
  bool isInLocalSubdomain_;
 
private:
  bool hasSlaveDof_;
};

template<class GlobalIDType>
class Record_Operator {
  public:
    virtual ~Record_Operator(){}

    virtual void operator()(Record<GlobalIDType>& record) = 0;
 
};//class Record_Operator
 
template<class GlobalIDType>
fei::Record<GlobalIDType>::Record()
  : ID_(-1),
    number_(-1),
    fieldMask_(NULL),
    offsetIntoEqnNumbers_(0),
    ownerProc_(-1),
    isInLocalSubdomain_(false),
    hasSlaveDof_(false)
{
}
 
template<class GlobalIDType>
fei::Record<GlobalIDType>::~Record()
{
}
 
 
} //namespace fei
 
#endif // _fei_Record_hpp_