STK_Cell.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004  Serge Iovleff
 
    This program 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 of the
    License, or (at your option) any later version.
 
    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.
 
    You should have received a copy of the GNU Lesser General Public
    License along with this program; if not, write to the
    Free Software Foundation, Inc.,
    59 Temple Place,
    Suite 330,
    Boston, MA 02111-1307
    USA
 
    Contact : S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)                                   */
 
/*
 * Project: stkpp::DManager
 * Purpose:  Define the template CellBase, CellVe and CellHo classes.
 * Author:   Serge Iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 *
 **/
 
#ifndef STK_CELL_H
#define STK_CELL_H
 
namespace STK
{
template<class Type>
class CellBase
{
  protected:
    Type data_;        
 
  public:
    CellBase() : data_(Type()) {}
    CellBase( Type const& data): data_(data)
    {}
    CellBase( const CellBase<Type> &C): data_(C.data_)
    {}
    virtual ~CellBase() {}
    CellBase<Type>& operator=(const CellBase<Type> &C)
    { data_ = C.data_; return *this;}
    CellBase<Type>& operator=(Type const& v)
    { data_ = v; return *this;}
    inline Type const& data() const { return data_;}
    inline Type& data() { return data_;}
    void setData(Type const& data) { data_ = data;}
};
 
template<class Type>
class CellVe : virtual public CellBase<Type>
{
  using STK::CellBase<Type>::data_;
 
  protected:
    CellVe<Type>* up_;        
    CellVe<Type>* down_;      
 
  public:
    CellVe( CellVe<Type>* up =0, CellVe<Type>* down =0);
 
    CellVe( CellVe<Type>* up
          , CellVe<Type>* down
          , Type const& data);
    
    CellVe(const CellVe<Type> &C);
 
    virtual ~CellVe();
 
    CellVe<Type>& operator=(const CellVe<Type> &C);
 
    CellVe<Type>& operator=(Type const& v);
 
    CellVe<Type>* getUp()  const;
 
    CellVe<Type>* getDown()  const;
 
    void setUp(CellVe<Type>* pcell);
 
    void setDown(CellVe<Type>* pcell);
};
 
template<class Type>
class CellHo : virtual public CellBase<Type>
{
  // needed for template classes
  using STK::CellBase<Type>::data_;
  
  protected:
    CellHo<Type> *left_;        
    CellHo<Type> *right_;       
 
  public:
    CellHo(CellHo<Type> *left =NULL, CellHo<Type> *right =NULL)
    { left_ = left; right_ = right;}
    
    CellHo( CellHo<Type>* left, CellHo<Type>* right, Type const& data)
          : CellBase<Type>(data)
    { left_ = left; right_ = right; }
    
    CellHo( const CellHo<Type> &C)
          : CellBase<Type>(C)
          , left_(C.left_)
          , right_(C.right_)
    { ;}
 
    virtual ~CellHo() { ;}
    
    CellHo<Type>& operator=(const CellHo<Type> &C)
    { data_ = C.data_; 
      left_ = C.left_;
      right_ = C.right_;
      return *this;
    }
    
    CellHo<Type>& operator=(Type const& v)
    { data_ = v;
      return *this;
    }
 
    CellHo<Type>* getLeft()  const
    { return left_;}
 
    CellHo<Type>* getRight()  const
    { return right_;}
 
    void setLeft(CellHo<Type>* left)
    { left_ = left;}
    
    void setRight(CellHo<Type>* right)
    { right_ = right;}
};
 
template<class Type>
class Cell2D : virtual public CellVe<Type>
             , virtual public CellHo<Type>
{
  using STK::CellBase<Type>::data_;
  using STK::CellHo<Type>::up_;
  using STK::CellHo<Type>::down_;
  using STK::CellVe<Type>::left_;
  using STK::CellVe<Type>::right_;
 
  public:
    Cell2D( const Cell2D<Type>* left  =NULL
          , const Cell2D<Type>* up    =NULL
          , const Cell2D<Type>* right =NULL
          , const Cell2D<Type>* down  =NULL);
 
    Cell2D( const Cell2D<Type>* left
          , const Cell2D<Type>* up
          , const Cell2D<Type>* right
          , const Cell2D<Type>* down
          , Type const& data);
    
    Cell2D(const Cell2D<Type> &C);
 
    virtual ~Cell2D();
 
    Cell2D<Type>& operator=(const Cell2D<Type> &C);
 
    Cell2D<Type>& operator=(Type const& v);
};
 
// Constructor with a pointer on the data
template<class Type>
CellVe<Type>::CellVe( CellVe<Type>* up
                        , CellVe<Type>* down)
                        : CellBase<Type>()
{ up_ = up; down_ = down;}
 
// Constructor with a reference to the data
template<class Type>
CellVe<Type>::CellVe( CellVe<Type>* up
                        , CellVe<Type>* down
                        , Type const& data)
                        : CellBase<Type>(data)
{ up_ = up; down_ = down; }
 
// Copy Constructor.
template<class Type>
CellVe<Type>::CellVe(const CellVe<Type> &C)
{ data_ = C.data_;  up_   = C.up_; down_ = C.down_; }
 
/* virtual destructor.                                                  */
template<class Type>
CellVe<Type>::~CellVe() { ;}
 
/* operator = : overwrite the Cell with C.                              */
template<class Type>
CellVe<Type>&
CellVe<Type>::operator=(const CellVe<Type> &C)
{ data_ = C.data_;  up_ = C.up_; down_ = C.down_;
  return *this;
}
 
/* operator = : overwrite the data with v.                              */
template<class Type>
CellVe<Type>& CellVe<Type>::operator=(Type const& v)
{ data_ = v;
  return *this;
}
 
/* Accessors.                                                          */
template<class Type>
CellVe<Type>* CellVe<Type>::getUp()  const
{ return up_;}
 
// Give the adress of the cell down
template<class Type>
CellVe<Type>* CellVe<Type>::getDown()  const
{ return down_;}
 
// Set the adress of the cell up
template<class Type>
void CellVe<Type>::setUp(CellVe<Type>* up)
{ up_ = up;}
 
// Set the adress of the cell down
template<class Type>
void CellVe<Type>::setDown(CellVe<Type>* down)
{ down_ = down;}
 
// Constructor with a pointer on the data
template<class Type>
Cell2D<Type>::Cell2D( const Cell2D<Type>* left
                    , const Cell2D<Type>* up
                    , const Cell2D<Type>* right
                    , const Cell2D<Type>* down)
                    : CellBase<Type>()
                    , CellHo<Type>(left, right)
                    , CellVe<Type>(up, down)
{ ;}
 
// Constructor with a reference to the data
template<class Type>
Cell2D<Type>::Cell2D( const Cell2D<Type>* left
                    , const Cell2D<Type>* up
                    , const Cell2D<Type>* right
                    , const Cell2D<Type>* down
                    , Type const& data)
                    : CellBase<Type>(data)
                    , CellHo<Type>(left, right)
                    , CellVe<Type>(up, down)
{ ;}
 
// Copy Constructor.
template<class Type>
Cell2D<Type>::Cell2D(const Cell2D<Type>& C)
{ data_  = C.data_;
  up_    = C.up_;
  down_  = C.down_;
  left_  = C.left_;
  right_ = C.right_;
}
 
/* virtual destructor.                                                  */
template<class Type>
Cell2D<Type>::~Cell2D() { ;}
 
/* operator = : overwrite the Cell with C.                              */
template<class Type>
Cell2D<Type>&
Cell2D<Type>::operator=(const Cell2D<Type> &C)
{ data_  = C.data_;
  up_    = C.up_;
  down_  = C.down_;
  left_  = C.left_;
  right_ = C.right_;
}
 
/* operator = : overwrite the data with v.                              */
template<class Type>
Cell2D<Type>& Cell2D<Type>::operator=(Type const& v)
{ data_ = v;}
 
 
} // namespace STK
 
#endif
// STK_CELL_H