Window.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: Window.h,v 1.12 2008/12/06 08:43:24 mtcampbe Exp $

/* Author: Xiangmin Jiao */

#ifndef __ROCCOM_WINDOW_H__
#define __ROCCOM_WINDOW_H__

#include "Function.h"
#include "Pane.h"
#include <map>

COM_BEGIN_NAME_SPACE

class Window {
  typedef std::map< std::string, Function>           Func_map;
  typedef std::map< std::string, Attribute*>         Attr_map;
  typedef std::map< int, Pane*>                      Pane_map;

  class Pane_friend : public Pane {
    explicit Pane_friend( Pane&);
  public:
    using Pane::new_attribute;
    using Pane::delete_attribute;
    using Pane::inherit;
    using Pane::set_size;
    using Pane::reinit_attr;
    using Pane::reinit_conn;
    using Pane::connectivity;
  };
  typedef Pane::OP_Init    OP_Init;

public:
  typedef std::map<int,int>                          Proc_map;

  // Used by get_array. Note that the default dimension is -1, which
  // is for void*. Nonnegative dimensions are reserved for Fortran pointers.
  struct Pointer_descriptor {
    explicit Pointer_descriptor( void *p, int d=-1) 
      : ptr(p), dim(d), n1(0), n2(0) {}
    void *at() { return ptr; }

    void *ptr;
    int  dim;
    int  n1, n2;
  };

  Window( const std::string &name, MPI_Comm c);

  virtual ~Window();
  //\}

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

  MPI_Comm get_communicator() const { return _comm; }
  //\}

  void set_function( const std::string &fname, 
                     Func_ptr func,
                     const std::string &intents, 
                     const COM_Type *types, 
                     Attribute *a, 
                     bool if_f90=false) throw(COM_exception);

  void set_function( const std::string &fname, 
                     Member_func_ptr func,
                     const std::string &intents, 
                     const COM_Type *types, 
                     Attribute *a, 
                     bool if_f90=false) throw(COM_exception);

  Attribute *new_attribute( const std::string &aname, const char loc,
                            const int type, int ncomp,
                            const std::string &unit) throw(COM_exception);

  void delete_attribute( const std::string &aname) throw(COM_exception);

  void set_size( const std::string &aname, int pane_id,
                 int nitems, int ng=0) throw( COM_exception);

  void set_array( const std::string &aname, const int pane_id,
                  void *addr, int strd=0, int cap=0, bool is_const=false) 
    throw(COM_exception);

  void alloc_array( const std::string &aname, const int pane_id,
                    void **addr, int strd=0, int cap=0) throw(COM_exception);

  void resize_array( const std::string &aname, const int pane_id,
                     void **addr, int strd=-1, int cap=0) throw(COM_exception);

  void resize_array( Attribute *a, void **addr, 
                     int strd=-1, int cap=0) throw(COM_exception) 
  { reinit_attr( a, Pane::OP_RESIZE, addr, strd, cap); }

  void resize_array( Connectivity *c, void **addr, 
                     int strd=-1, int cap=0) throw(COM_exception) 
  { reinit_conn( c, Pane::OP_RESIZE, (int**)addr, strd, cap); }

  void append_array( const std::string &aname, const int pane_id,
                     const void *val, int v_strd, int v_size) throw(COM_exception);

  void dealloc_array( const std::string &aname,
                      const int pane_id=0) throw(COM_exception);

  void dealloc_array( Attribute *a) throw(COM_exception)
  { reinit_attr( a, Pane::OP_DEALLOC); }

  void dealloc_array( Connectivity *c) throw(COM_exception) 
  { reinit_conn( c, Pane::OP_DEALLOC); }

  Attribute *inherit( Attribute *from, const std::string &aname, 
                      int inherit_mode, bool withghost,
                      const Attribute *cond, int val) throw(COM_exception);

  void copy_attribute( const Attribute *from, 
                       Attribute *to) throw(COM_exception) {
    inherit( const_cast<Attribute*>(from), to->name(), 
             Pane::INHERIT_COPY, true, NULL, 0);
  }
  
  Attribute *get_attribute( const std::string &aname, char *l, int *t, 
                            int *n, std::string *u) const throw(COM_exception);
  
  void get_size( const std::string &aname, int pane_id, 
                 int *nitems, int *ng) const throw( COM_exception);

  int get_status( const std::string &aname, int pane_id) const 
    throw(COM_exception);

  void get_parent( const std::string &aname, int pane_id,
                   std::string &name) const throw(COM_exception);

  void get_array( const std::string &aname, const int pane_id, 
                  Pointer_descriptor &addr, 
                  int *strd=NULL, int *cap=NULL, bool is_const=false) 
    throw(COM_exception);

  void copy_array( const std::string &aname, const int pane_id, 
                   void *val, int v_strd=0, int v_size=0, 
                   int offset=0) const throw(COM_exception);

  void init_done( bool pane_changed=true) throw(COM_exception);

  //\}

  int size_of_panes() const { return _pane_map.size(); }

  int size_of_panes_global() const { return _proc_map.size(); }

  int owner_rank( const int pane_id) const;

  int last_attribute_id() const { return _last_id; }

  const Proc_map &proc_map() const { return _proc_map; }

  void delete_pane( const int pane_id) throw(COM_exception) {
    if ( pane_id == 0) { // delete all panes
      _pane_map.clear();
    }
    else {
      Pane_map::iterator it = _pane_map.find( pane_id);
      if ( it == _pane_map.end()) throw COM_exception(COM_ERR_PANE_NOTEXIST);
      delete it->second;
      _pane_map.erase( it);
    }
  }

  //\}
 
  Pane &pane( const int pane_id, bool insert=false) throw(COM_exception);
  const Pane &pane( const int pane_id) const throw(COM_exception);

  void panes( std::vector<int> &ps, int rank=-2);

  void panes( std::vector<Pane*> &ps);
  void panes( std::vector<const Pane*> &ps) const
  { const_cast<Window*>(this)->panes( (std::vector<Pane*> &)ps); }

  void attributes( std::vector<Attribute*> &as)
  { _dummy.attributes( as); }
  void attributes( std::vector< const Attribute*> &as) const
  { _dummy.attributes( as); }

  Attribute *attribute( const std::string &a) throw(COM_exception);
  const Attribute *attribute( const std::string &a) const throw(COM_exception)
  { return const_cast<Window*>(this)->attribute( a); }

  Attribute *attribute( int i) throw(COM_exception) 
  { return _dummy.attribute( i); }
  const Attribute *attribute( int i) const throw(COM_exception) 
  { return _dummy.attribute( i); }

  Function *function( const std::string &f);
  const Function *function( const std::string &f) const
  { return const_cast<Window*>(this)->function( f); }
  //\}

protected:
  void reinit_attr( Attribute *attr, OP_Init op, void **addr=NULL, 
                    int strd=0, int cap=0) throw(COM_exception);

  void reinit_conn( Connectivity *con, OP_Init op, int **addr=NULL, 
                    int strd=0, int cap=0) throw(COM_exception);

protected:
  Pane         _dummy;       
  std::string  _name;        
  Attr_map     _attr_map;    
  Func_map     _func_map;    
  Pane_map     _pane_map;    
  Proc_map     _proc_map;    
 
  int          _last_id;     
  MPI_Comm     _comm;        
  enum { STATUS_SHRUNK, STATUS_CHANGED, STATUS_NOCHANGE };
  int          _status;      

private:
  // Disable the following two functions (they are dangerous)
  Window( const Window&);
  Window &operator=( const Window&);

private:
#ifdef DOXYGEN
  // This is to fool DOXYGEN to generate the correct collabration diagram
  Attribute   *_attr_map;
  Function    *_func_map;
  Pane        *_pane_map;
#endif /* DOXYGEN */

};

COM_END_NAME_SPACE

#endif