schema_poset_member.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 SCHEMA_POSET_MEMBER_H
#define SCHEMA_POSET_MEMBER_H

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

#ifndef TOTAL_POSET_MEMBER_H
#include "SheafSystem/total_poset_member.h"
#endif

#ifndef EXPLICIT_INDEX_SPACE_HANDLE_H
#include "SheafSystem/explcit_index_space_handle.h"
#endif

#ifndef STD_UNORDERED_MAP_H
#include "SheafSystem/std_unordered_map.h"
#endif

#ifndef STD_LIST_H
#include "SheafSystem/std_list.h"
#endif

#ifndef STD_IOSTREAM_H
#include "SheafSystem/std_iostream.h"
#endif

#ifndef PRIMITIVES_POSET_DOF_MAP_H
#include "SheafSystem/primitives_poset_dof_map.h"
#endif

#ifndef STD_STRING_H
#include "SheafSystem/std_string.h"
#endif

namespace sheaf
{

template <typename T> class block;
template <class T> class wsv_block;
class index_iterator;
class list_cover_set;
class dof_descriptor_array;
class poset_bounds;
class poset_member_dof_iterator;
class poset_member_iterator;
class poset_dof_iterator;
class schema_descriptor;
class storage_agent;
class subposet;  

class SHEAF_DLL_SPEC schema_poset_member : public total_poset_member
{
  friend class array_poset_dof_map;
  friend class dof_tuple_record_set;
  friend SHEAF_DLL_SPEC size_t deep_size(const schema_poset_member& xp, bool xinclude_shallow);

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

public:

  // Typedefs:


  static const poset_path& standard_schema_path();

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

  static host_type& standard_host(namespace_type& xns, const poset_path& xhost_path, bool xauto_access);

protected:

private:


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

public:

  schema_poset_member();

  explicit schema_poset_member(const abstract_poset_member& xother,
                               bool xnew_jem = false,
                               bool xauto_access = true);

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

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

  schema_poset_member& operator=(const schema_poset_member& xother);

  virtual ~schema_poset_member();

  // NEW HANDLE, NEW STATE CONSTRUCTORS

  schema_poset_member(poset_state_handle* xhost,
                      primitive_type xprimitive_type,
                      bool xauto_access = true);

  explicit schema_poset_member(poset_state_handle* xhost,
                               primitives_poset_dof_map* xdof_map = 0,
                               bool xcopy_dof_map = false,
                               bool xauto_access = true);

  schema_poset_member(poset_state_handle* xhost,
                      const scoped_index* xexpansion,
                      int xexpansion_ct,
                      const tern& xnew_jem,
                      bool xauto_access);


  schema_poset_member(const namespace_poset& xns,
                      const std::string& xname,
                      const poset_path& xparent_path,
                      const wsv_block<schema_descriptor>& xdof_specs,
                      bool xauto_access);

  // NEW HANDLE, EXISTING STATE CONSTRUCTORS

  schema_poset_member(poset_state_handle* xhost, pod_index_type xhub_id);

  schema_poset_member(poset_state_handle* xhost, const scoped_index& xid);

  schema_poset_member(const poset_state_handle* xhost, const std::string& xname);

  schema_poset_member(const namespace_poset* xnamespace,
                      const poset_path& xpath,
                      bool xauto_access = true);

  // EXISTING HANDLE, NEW STATE "CONSTRUCTORS"

  // Make sure next declaration overloads
  // inherited new_jim_state functions.

  using total_poset_member::new_jim_state;

  void new_jim_state(primitive_type xprimitive_type,
                     bool xauto_access = true);

  void new_jim_state(poset_state_handle* xhost,
                     primitive_type xprimitive_type,
                     bool xauto_access = true);

  void new_jim_state(const namespace_poset& xns,
                     const std::string& xname,
                     const poset_path& xparent_path,
                     const wsv_block<schema_descriptor>& xdof_specs,
                     bool xauto_access);

  static int dof_ct(const namespace_poset& xns,
                    const poset_path& xpath,
                    bool xis_table_dof,
                    bool xauto_access = true);

  static int table_dof_ct(const namespace_poset& xns,
                          const poset_path& xpath,
                          bool xauto_access = true);

  static int row_dof_ct(const namespace_poset& xns,
                        const poset_path& xpath,
                        bool xauto_access = true);

  int dof_ct(bool xis_table_dof) const;

  int table_dof_ct() const;

  int row_dof_ct() const;

  virtual int dof_ct() const
  {
    return total_poset_member::dof_ct();
  };

  size_t dof_tuple_ub(bool xis_table_dof) const;

  size_t table_dof_tuple_ub() const;

  size_t row_dof_tuple_ub() const;

  virtual primitive_type dof_tuple_type(bool xis_table_dof) const;

  

  inline primitive_type table_dof_tuple_type() const
  {
    return dof_tuple_type(true);
  };

  

  inline primitive_type row_dof_tuple_type() const
  {
    return dof_tuple_type(false);
  };

  bool dof_tuple_is_homogeneous(bool xis_table_dof) const;

  inline bool table_dof_tuple_is_homogeneous() const
  {
    return dof_tuple_is_homogeneous(true);
  };

  inline bool row_dof_tuple_is_homogeneous() const
  {
    return dof_tuple_is_homogeneous(false);
  };

  static std::string dof_subposet_name(const std::string& xname, bool xis_table_dof);

  static inline std::string table_dof_subposet_name(const std::string& xname)
  {
    return dof_subposet_name(xname, true);
  };

  static inline std::string row_dof_subposet_name(const std::string& xname)
  {
    return dof_subposet_name(xname, false);
  };

  std::string dof_subposet_name(bool xis_table_dof) const;

  inline std::string table_dof_subposet_name() const
  {
    return dof_subposet_name(true);
  };

  inline std::string row_dof_subposet_name() const
  {
    return dof_subposet_name(false);
  };


  const scoped_index& table_dof_subposet_index() const;

  const scoped_index& row_dof_subposet_index() const;

  inline const scoped_index& dof_subposet_index(bool xis_table_dof) const
  {
    return xis_table_dof ? table_dof_subposet_index(): row_dof_subposet_index();
  };

  bool contains_dof(const schema_poset_member& xother, bool xin_table_dofs) const;

  inline bool contains_table_dof(const schema_poset_member& xother) const
  {
    return contains_dof(xother, true);
  };

  inline bool contains_row_dof(const schema_poset_member& xother) const
  {
    return contains_dof(xother, false);
  };

  bool contains_dof(pod_index_type xother_id, bool xin_table_dofs) const;

  bool contains_dof(const scoped_index& xother_id, bool xin_table_dofs) const;

  bool contains_dof(const std::string& xname, bool xin_table_dofs) const;

  inline bool contains_table_dof(pod_index_type xother_id) const
  {
    return contains_dof(xother_id, true);
  };

  inline bool contains_table_dof(const scoped_index& xother_id) const
  {
    return contains_dof(xother_id.hub_pod(), true);
  };

  inline bool contains_row_dof(pod_index_type xother_id) const
  {
    return contains_dof(xother_id, false);
  };

  inline bool contains_row_dof(const scoped_index& xother_id) const
  {
    return contains_dof(xother_id.hub_pod(), false);
  };

  virtual bool is_dof(bool xin_table_dofs) const;

  inline bool is_table_dof() const
  {
    return is_dof(true);
  };

  inline bool is_row_dof() const
  {
    return is_dof(false);
  };

  bool is_component() const;

  bool is_component_of(const schema_poset_member& xother) const;

  bool is_factor() const;

  bool is_factor_of(const schema_poset_member& xother) const;

  virtual size_t size() const;

  virtual size_t alignment() const;

  virtual primitive_type type() const;

  virtual poset_dof_iterator* dof_iterator(bool xis_table_dofs,
                       int xversion = CURRENT_MEMBER_VERSION) const;

  inline poset_dof_iterator* table_dof_iterator(int xversion = CURRENT_MEMBER_VERSION) const
  {
    return dof_iterator(true, xversion);
  };

  inline poset_dof_iterator* row_dof_iterator(int xversion = CURRENT_MEMBER_VERSION) const
  {
    return dof_iterator(false, xversion);
  };

  bool conforms_to(const schema_poset_member& xother) const;

  virtual bool conforms_to(const schema_poset_member& xother, bool xis_table_dofs) const;

  bool conforms_to(const poset_path& xpath) const;

  bool conforms_to(const poset_path& xpath, bool xis_table_dofs) const;

  bool table_conforms_to(const schema_poset_member& xother) const;

  bool table_conforms_to(const poset_path& xpath) const;

  bool row_conforms_to(const schema_poset_member& xother) const;

  bool row_conforms_to(const poset_path& xpath) const;

  static bool conforms_to(const namespace_poset& xns,
                          const poset_path& xchild_path,
                          const poset_path& xparent_path,
                          bool xauto_access = true);

  static bool conforms_to(const namespace_poset& xns,
                          const poset_path& xchild_path,
                          const poset_path& xparent_path,
                          bool xis_table_dofs,
                          bool xauto_access);

  static bool table_conforms_to(const namespace_poset& xns,
                                const poset_path& xchild_path,
                                const poset_path& xparent_path,
                                bool xauto_access = true);

  static bool row_conforms_to(const namespace_poset& xns,
                              const poset_path& xchild_path,
                              const poset_path& xparent_path,
                              bool xauto_access = true);


  static poset_path make_schema(const namespace_poset& xns,
                                const poset_path& xparent_path,
                                const std::string& xname);


  static void make_schema_no_jims(namespace_poset* xns,
                                  const std::string& xposet_name,
                                  const std::string& xmember_name,
                                  const std::string& xparent_name);

  static poset_path make_schema(const namespace_poset& xns,
                                const poset_path& xparent_path,
                                const std::string& xname,
                                const std::string xdof_names[],
                                const primitive_type xdof_types[],
                                const bool xis_table_dof[],
                                size_type xdof_ct,
                                bool xauto_access);

  static poset_path make_row_schema(const namespace_poset& xns,
                                    const poset_path& xparent_path,
                                    const std::string& xname,
                                    const std::string xdof_names[],
                                    const primitive_type xdof_types[],
                                    size_type xdof_ct,
                                    bool xauto_access);

  static poset_path
  make_homogeneous_row_schema(const namespace_poset& xns,
                              const poset_path& xparent_path,
                              const std::string& xname,
                              const std::string xdof_names[],
                              const primitive_type xdof_type,
                              size_type xdof_ct,
                              bool xauto_access);

  static void make_row_dofs_schema(namespace_poset*  xns,
                                   const std::string      member_names[],
                                   const int              num_members,
                                   const int              member_dof_type,
                                   const std::string&     schema_poset_name,
                                   const std::string&     schema_member_name,
                                   const std::string&     schema_inherits_name);

  static void make_table_dofs_schema(namespace_poset*  xns,
                                     const std::string      member_names[],
                                     const int              num_members,
                                     const int              member_dof_type,
                                     const std::string&     schema_poset_name,
                                     const std::string&     schema_member_name,
                                     const std::string&     schema_inherits_name);

  void force_cache_update();

  dof_descriptor_array* dof_descriptors(bool xis_table_dof) const;

  dof_descriptor_array* table_dof_descriptors() const;

  dof_descriptor_array* row_dof_descriptors() const;

protected:

  virtual void attach_handle_data_members();

  scoped_index _table_dof_subposet_index;

  scoped_index _row_dof_subposet_index;

  subposet_state* dof_subposet_state(bool xis_table_dof);

  mutable scoped_index _table_cache_index;

  mutable int _table_cache_version;

  bool table_cache_consistent() const;

  virtual void update_table_cache() const;

  virtual bool initialize_table_dof_id_space() const;

  virtual void update_table_dof_id_space() const;

  virtual void update_table_dof_descriptors() const;

  mutable scoped_index _row_cache_index;

  mutable int _row_cache_version;

  bool row_cache_consistent() const;

  virtual void update_row_cache(bool xupdate_id_space = false) const;

  virtual bool initialize_row_dof_id_space() const;

  virtual void update_row_dof_id_space() const;

  virtual void update_row_dof_descriptors() const;

  bool initialize_dof_id_space(bool xis_table_dof) const;

  void update_dof_id_space(bool xis_table_dof) const;

  void update_dof_descriptors(bool xis_table_dof,
                  dof_descriptor_array*& xdof_descriptors,
                  size_type xdof_ct,
                  size_type& xdof_tuple_ub) const;

  mutable size_type _table_dof_ct;

  mutable size_type _row_dof_ct;

  mutable size_type _table_dof_tuple_ub;

  mutable size_type _row_dof_tuple_ub;

  mutable dof_descriptor_array* _table_dof_descriptors;

  mutable dof_descriptor_array* _row_dof_descriptors;

private:



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

public:
  
  const index_space_handle& dof_id_space(bool xis_table_dofs) const;
 
  const index_space_handle& dof_id_space(bool xis_table_dofs, bool xauto_access) const;
  
  const index_space_handle& table_dof_id_space() const;
 
  const index_space_handle& table_dof_id_space(bool xauto_access) const;
  
  const index_space_handle& row_dof_id_space() const;
 
  const index_space_handle& row_dof_id_space(bool xauto_access) const;

  using total_poset_member::name;
  
  std::string name(pod_index_type xdof_id, bool xis_table_dof) const;
 
  std::string name(const scoped_index& xdof_id, bool xis_table_dof, bool xauto_access) const;
  
  virtual size_type size(pod_index_type xdof_id, bool xis_table_dof) const;
 
  size_type size(const scoped_index& xdof_id, bool xis_table_dof, bool xauto_access) const;

  size_type size(const std::string& xname, bool xis_table_dof, bool xauto_access) const;

  virtual size_type alignment(pod_index_type xdof_id, bool xis_table_dof) const;

  size_type alignment(const scoped_index& xdof_id, bool xis_table_dof, bool xauto_access) const;

  size_type alignment(const std::string& xname, bool xis_table_dof, bool xauto_access) const;

  virtual primitive_type type(pod_index_type xdof_id,
                  bool xis_table_dof) const;

  primitive_type type(const scoped_index& xdof_id, bool xis_table_dof,
              bool xauto_access) const;

  primitive_type type(const std::string& xname, bool xis_table_dof, bool xauto_access) const;

  virtual size_type offset(pod_index_type xdof_id, bool xis_table_dof) const;

  size_type offset(const scoped_index& xdof_id, bool xis_table_dof,
           bool xauto_access) const;

  size_type offset(const std::string& xname, bool xis_table_dof, bool xauto_access) const;

protected:
  
  mutable index_space_handle* _table_dof_id_space;

  mutable index_space_handle* _row_dof_id_space;

private:



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

public:

  // The product subposet hack, version 2 (PSH2).
  // ============================================
  // The abstraction that PSH2 exports via the virtual functions below
  // and their use in the i/o susbsystem is:
  //
  // 1) All member ids, in particular those associated with bounds and
  //    bound iterators, are actual member ids for the poset they belong to.
  //    The PSH1 use of section space schema member ids that were actually
  //    base space member ids is now gone.
  //
  // 2) Subposet ids appearing in bounds are base space subposet ids
  //    for section space schema classes and ordinary subposet ids for
  //    all other classes.
  //
  // 3) All conversion of base space ids to schema ids is handled by
  //    virtual functions in poset_state_handle, schema_poset_member,
  //    and their descendants.

  virtual index_iterator* get_decomposition(pod_index_type xindex) const;

  index_iterator* bound_iterator(const poset_bounds& xbnd_id, bool xis_ub) const;

  virtual pod_index_type get_int_id(pod_index_type xext_id,
                    const std::string& xid_space_name) const;

  virtual pod_index_type get_ext_id(const std::string& xid_space_name) const;

  virtual void get_ext_ids(const std::string& xid_space_name,
                           pod_index_type& xschema_poset_ext_id,
                           pod_index_type& xschema_member_ext_id,
                           pod_index_type& xbase_space_ext_id,
                           pod_index_type& xfiber_schema_ext_id,
                           pod_index_type& xlocal_schema_ext_id) const;

  virtual schema_poset_member& ext_data_type_schema();

  virtual size_t ext_data_type_ct(bool xis_table_schema) const;

protected:

private:



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

public:

  virtual primitives_poset_dof_map& dof_map(bool xrequire_write_access = false);

  virtual const primitives_poset_dof_map& dof_map(bool xrequire_write_access = false) const;

  virtual bool dof_map_is_ancestor_of(const poset_dof_map* xdof_map) const;

protected:

private:



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

public:

  inline schema_poset_member* greatest_jem() const
  {
    return static_cast<schema_poset_member*>(abstract_poset_member::greatest_jem());
  };

  inline schema_poset_member* least_jem() const
  {
    return static_cast<schema_poset_member*>(abstract_poset_member::least_jem());
  };

protected:

private:



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

public:

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

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

protected:

private:



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

public:

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

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

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

protected:

private:



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

public:

  virtual void detach_from_state();

protected:

private:



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

public:

  virtual bool is_ancestor_of(const any* other) const;

  virtual schema_poset_member* clone() const;

  virtual bool invariant() const;

protected:

private:

};

// ===========================================================
// NON-MEMBER FUNCTIONS
// ===========================================================

SHEAF_DLL_SPEC
size_t deep_size(const schema_poset_member& xp, bool xinclude_shallow = true);

} // namespace sheaf

#endif // SCHEMA_POSET_MEMBER_H