homogeneous_block.h

Go to the documentation of this file.

//
// Copyright (c) 2014 Limit Point Systems, Inc. 
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//


#ifndef HOMOGENEOUS_BLOCK_H
#define HOMOGENEOUS_BLOCK_H

#ifndef SHEAF_DLL_SPEC_H
#include "SheafSystem/sheaf_dll_spec.h"
#endif

#ifndef BASE_SPACE_MEMBER_H
#include "SheafSystem/base_space_member.h"
#endif

namespace sheaf
{
class index_space_handle;
class index_space_iterator;
class hub_index_space_handle;
  
}

namespace fiber_bundle
{

using namespace sheaf;

class homogeneous_block_crg_interval;
  
class SHEAF_DLL_SPEC homogeneous_block : public base_space_member
{
  // ===========================================================
  // ===========================================================

public:

  static host_type& new_host(namespace_type& xns, 
                 const poset_path& xhost_path, 
                 const poset_path& xschema_path, 
                 int xmax_db,
                 bool xauto_access);

  static host_type& new_host(namespace_type& xns,
                 const poset_path& xhost_path,
                 int xmax_db,
                 bool xauto_access);
  

protected:

private:



  // ===========================================================
  // ===========================================================

public:

  virtual ~homogeneous_block();

  const hub_index_space_handle& hub_id_space() const;

  const index_space_handle& local_id_space() const;

  const pod_index_type& local_cell_type_id() const;

  const char* local_cell_type_name() const;

  virtual const size_type& size() const;

  using base_space_member::new_row_dof_map;

  array_poset_dof_map* new_row_dof_map(const poset* xhost,
                                       const std::string& xprototype_name,
                                       const std::string& xlocal_cell_name,
                                       size_type xsize);

  static const scoped_index& new_row_dof_map(poset_state_handle& xhost,
                         const std::string& xprototype_name,
                         const std::string& xlocal_cell_name,
                         size_type xsize,
                         bool xauto_access);

protected:

  homogeneous_block();

  virtual void attach_handle_data_members();

  virtual const homogeneous_block_crg_interval& interval() const;

  void put_size(const size_type& xsize);

//   ///
//   /// The type of row dof tuple for this.
//   ///
//   struct SHEAF_DLL_SPEC row_dof_tuple_type
//   {
//     ///
//     /// The base space dimension.
//     ///
//     int db;

//     ///
//     /// The cell type id.
//     ///
//     int type_id;

//     ///
//     /// The cell type name.
//     ///
//     const char* type_name;

//     ///
//     /// The refinement depth.
//     ///
//     int refinement_depth;

//     ///
//     /// The local cell type id.
//     ///
//     int local_cell_type_id;

//     ///
//     /// The local cell type name.
//     ///
//     const char * local_cell_type_name;

//     ///
//     /// The number of local cell instances in this block.
//     ///
//     size_type size;
//   };


//   ///
//   /// The row dof tuple for this.
//   ///
//   inline row_dof_tuple_type* row_dof_tuple()
//   {
//     return reinterpret_cast<row_dof_tuple_type*>(dof_map().dof_tuple());
//   }

  homogeneous_block_crg_interval* _interval;

private:



  // ===========================================================
  // ===========================================================

public:

  bool contains_zone_id_space(bool xauto_access) const;

  index_space_handle& get_zone_id_space(bool xauto_access) const;

  void release_zone_id_space(index_space_handle& xid_space, bool xauto_access) const;

  index_space_iterator& get_zone_id_space_iterator(bool xauto_access) const;

  void release_zone_id_space_iterator(index_space_iterator& xitr, bool xauto_access) const;

protected:

private:



  // ===========================================================
  // ===========================================================

public:

  bool contains_vertex_id_space(bool xauto_access) const;

  index_space_handle& get_vertex_id_space(bool xauto_access) const;

  void release_vertex_id_space(index_space_handle& xid_space, bool xauto_access) const;

  index_space_iterator& get_vertex_id_space_iterator(bool xauto_access) const;

  void release_vertex_id_space_iterator(index_space_iterator& xitr, bool xauto_access) const;

protected:

private:



  // ==========================================================
  // ===========================================================

public:

  bool contains_connectivity_id_space(pod_index_type xzone_id, bool xauto_access) const;

  bool contains_connectivity_id_space(const scoped_index& xzone_id, bool xauto_access) const;

  index_space_handle& get_connectivity_id_space(pod_index_type xzone_id, bool xauto_access) const;

  index_space_handle& get_connectivity_id_space(const scoped_index& xzone_id, bool xauto_access) const;

  void release_connectivity_id_space(index_space_handle& xid_space, bool xauto_access) const;

  index_space_iterator& get_connectivity_id_space_iterator(pod_index_type xzone_id, bool xauto_access) const;

  index_space_iterator& get_connectivity_id_space_iterator(const scoped_index& xzone_id, bool xauto_access) const;

  void release_connectivity_id_space_iterator(index_space_iterator& xid_space, bool xauto_access) const;

protected:

private:



  // ==========================================================
  // ===========================================================

public:

  bool contains_adjacency_id_space(pod_index_type xvertex_id, bool xauto_access) const;

  bool contains_adjacency_id_space(const scoped_index& xvertex_id, bool xauto_access) const;

  index_space_handle& get_adjacency_id_space(pod_index_type xvertex_id, bool xauto_access) const;

  index_space_handle& get_adjacency_id_space(const scoped_index& xvertex_id, bool xauto_access) const;

  void release_adjacency_id_space(index_space_handle& xid_space, bool xauto_access) const;

  index_space_iterator& get_adjacency_id_space_iterator(pod_index_type xvertex_id, bool xauto_access) const;

  index_space_iterator& get_adjacency_id_space_iterator(const scoped_index& xvertex_id, bool xauto_access) const;

  void release_adjacency_id_space_iterator(index_space_iterator& xid_space, bool xauto_access) const;

protected:

private:



  // ===========================================================
  // ===========================================================

public:

protected:

private:



  // ===========================================================
  // ===========================================================

public:

protected:

private:



  // ===========================================================
  // ===========================================================

public:

  virtual homogeneous_block* clone() const = 0;

  inline homogeneous_block* clone(bool xnew_state, bool xauto_access = true) const
  {
    return static_cast<homogeneous_block*>(base_space_member::clone(xnew_state, xauto_access));
  }

protected:

private:



  // ===========================================================
  // ===========================================================

public:

  inline homogeneous_block* greatest_jem() const
  {
    return static_cast<homogeneous_block*>(base_space_member::greatest_jem());
  };

  inline homogeneous_block* least_jem() const
  {
    return static_cast<homogeneous_block*>(base_space_member::least_jem());
  };

protected:

private:



  // ===========================================================
  // ===========================================================

public:

  inline homogeneous_block* p_join(abstract_poset_member* other) const
  {
    return static_cast<homogeneous_block*>(base_space_member::p_join(other));
  };

  inline homogeneous_block* p_meet(abstract_poset_member* other)
  {
    return static_cast<homogeneous_block*>(base_space_member::p_meet(other));
  };

protected:

private:



  // ===========================================================
  // ===========================================================

public:

  inline homogeneous_block* l_join(abstract_poset_member* other, bool xnew_jem = true)
  {
    return static_cast<homogeneous_block*>(base_space_member::l_join(other, xnew_jem));
  };

  inline homogeneous_block* l_meet(abstract_poset_member* other, bool xnew_jem = true)
  {
    return static_cast<homogeneous_block*>(base_space_member::l_meet(other, xnew_jem));
  };

  inline homogeneous_block* l_not(bool xnew_jem = true) const
  {
    return static_cast<homogeneous_block*>(base_space_member::l_not(xnew_jem));
  };

protected:

private:



  // ===========================================================
  // ===========================================================

public:

  virtual bool invariant() const;

  virtual bool is_ancestor_of(const any* other) const;

  virtual homogeneous_block& operator=(const abstract_poset_member& xother);

  homogeneous_block& operator=(const homogeneous_block& xother);

protected:

private:

};
  
} // namespace fiber_bundle

#endif // HOMOGENEOUS_BLOCK_H