abstract_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 ABSTRACT_POSET_MEMBER_H
#define ABSTRACT_POSET_MEMBER_H

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

#ifndef POSET_COMPONENT_H
#include "SheafSystem/poset_component.h"
#endif

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

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


namespace sheaf
{

template <typename T> class block;
class poset_dof_map;
class poset_member_iterator;
class poset_path;
class schema_poset_member;
class sheaves_namespace;
class storage_agent;
class subposet;
class tern;
  

// ============================================================================
// CLASS ABSTRACT_POSET_MEMBER_TABLE_DOFS_TYPE
// ============================================================================
  
class SHEAF_DLL_SPEC abstract_poset_member_table_dofs_type
{
  // ===========================================================
  // ===========================================================

public:

  typedef unsigned char dof_type;

  typedef abstract_poset_member_table_dofs_type table_dofs_type;

  dof_type& operator[] (size_type xi);

  const dof_type& operator[] (size_type xi) const;

  table_dofs_type* clone() const;

protected:

private:

};


// ============================================================================
// CLASS ABSTRACT_POSET_MEMBER_ROW_DOFS_TYPE
// ============================================================================
  
class SHEAF_DLL_SPEC abstract_poset_member_row_dofs_type
{
  // ===========================================================
  // ===========================================================

public:

  typedef unsigned char dof_type;

  typedef abstract_poset_member_row_dofs_type row_dofs_type;

  dof_type& operator[] (size_type xi);

  const dof_type& operator[] (size_type xi) const;

  row_dofs_type* clone() const;

protected:

private:

};


// ============================================================================
// CLASS ABSTRACT_POSET_MEMBER
// ============================================================================
  
class SHEAF_DLL_SPEC abstract_poset_member : public poset_component
{

  friend class cover_set_iterator;
  friend class filtered_iterator;
  friend class poset_dft;
  friend class poset_joiner;
  friend class poset_orderer;
  friend class poset_state_handle;
  friend class postorder_iterator;
  friend class subposet_joiner;
  friend class storage_agent;
  // friend std::ostream & operator << (std::ostream &os, abstract_poset_member& p);


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

public:

  // Typedefs:

  typedef namespace_poset namespace_type;

  typedef poset host_type;  

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

protected:

private:


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

public:

  // Typedefs:

  typedef abstract_poset_member_table_dofs_type table_dofs_type;

  typedef abstract_poset_member_row_dofs_type row_dofs_type;


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

  virtual ~abstract_poset_member();

  abstract_poset_member* clone(bool xnew_state, bool xauto_access = true) const;

  // EXISTING HANDLE, NEW STATE "CONSTRUCTORS"

  virtual void new_jim_state(poset_dof_map* xdof_map = 0,
                             bool xcopy_dof_map = false,
                             bool xauto_access = true);

  virtual void new_jim_state(pod_index_type xtuple_id, bool xauto_access = true);

  void new_jim_state(const scoped_index& xtuple_id, bool xauto_access = true);

  virtual void new_jim_state(poset_state_handle* xhost,
                             poset_dof_map* xdof_map = 0,
                             bool xcopy_dof_map = false,
                             bool xauto_access = true);

  virtual void new_jim_state(poset_state_handle* xhost,
                 pod_index_type xtuple_id,
                 bool xauto_access = true);

  void new_jim_state(poset_state_handle* xhost,
             const scoped_index& xtuple_id,
             bool xauto_access = true);

  virtual void new_jrm_state(bool xauto_access = true);

  virtual void new_jrm_state(poset_state_handle* xhost, bool xauto_access = true);

  virtual void new_jrm_state(const scoped_index* xexpansion,
                             int xexpansion_ct,
                             const tern& xgreatest,
                             bool xauto_access = true);

  virtual void new_jrm_state(poset_state_handle* xhost,
                             const scoped_index* xexpansion,
                             int xexpansion_ct,
                             const tern& xgreatest,
                             bool xauto_access = true);


  virtual void new_jem_state(abstract_poset_member* xother,
                             bool xgreatest,
                             bool xauto_access);

  virtual void new_jem_state(poset_state_handle* xhost,
                 pod_index_type xhub_id,
                 bool xgreatest,
                 bool xauto_access);

  void new_jem_state(poset_state_handle* xhost,
             const scoped_index& xid,
             bool xgreatest,
             bool xauto_access);

protected:
  abstract_poset_member();

  virtual void attach_handle_data_members();

  char* table_dof_ptr(bool xrequire_write_access = false) const;

  char* row_dof_ptr(bool xrequire_write_access = false);

private:




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

public:

  virtual bool is_jim(bool xin_current_version = true) const;

  virtual bool is_atom() const;

protected:

private:



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

public:

  virtual schema_poset_member& schema();

  virtual const schema_poset_member& schema() const;

  schema_poset_member& schema(bool xauto_access);

  const schema_poset_member& schema(bool xauto_access) const;

  virtual schema_poset_member& unrestricted_schema();

  virtual const schema_poset_member& unrestricted_schema() const;

  bool schema_is(const std::string& xschema_name) const;

  bool same_schema(const abstract_poset_member* xother) const;

protected:

private:



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

public:

  virtual bool is_restricted() const;

  virtual bool is_same_restriction(const abstract_poset_member* xother) const;

protected:

private:



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

public:

  virtual int dof_ct() const = 0;

  virtual poset_dof_map& dof_map(bool xrequire_write_access = false);

  virtual const 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;

  void dof_tuple(const void* xbuf, size_t xbuflen) const;

  void put_dof_tuple(const void* xbuf, size_t xbuflen);

  pod_index_type dof_tuple_id(bool xauto_access) const;

  void dof_tuple_id(scoped_index& result, bool xauto_access) const;

  void put_dof_tuple_id(pod_index_type xtuple_index, bool xauto_access);

  void put_dof_tuple_id(const scoped_index& xtuple_index, bool xauto_access);

  void* table_dofs();

  const void* table_dofs() const;

  void* table_dofs(bool xauto_access);

  const void* table_dofs(bool xauto_access) const;

  void* row_dofs();

  const void* row_dofs() const;

  void* row_dofs(bool xauto_access);

  const void* row_dofs(bool xauto_access) const;

protected:

private:



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

public:
 
  primitive_value dof(pod_index_type xdof_id) const;

  primitive_value dof(const scoped_index& xdof_id, bool xauto_access) const;

  void put_dof(pod_index_type xdof_id, const primitive_value& xdof);

  void put_dof(const scoped_index& xdof_id, const primitive_value& xdof, bool xauto_access);

  void get_dof(pod_index_type xdof_id, void* xdof, size_type xdof_size) const;

  void get_dof(const scoped_index& xdof_id, void* xdof, size_type xdof_size, bool xauto_access) const;

  void put_dof(pod_index_type xdof_id, const void* xdof, size_type xdof_size);

  void put_dof(const scoped_index& xdof_id, const void* xdof, size_type xdof_size, bool xauto_access);

protected:

private:

 

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

public:
 
  bool le(pod_index_type xother_index) const;

  bool le(const scoped_index& xother_index) const;

  bool le(const abstract_poset_member* other) const ;

  bool leqv(pod_index_type xother_index) const;

  bool leqv(const scoped_index& xother_index) const;

  bool lt(pod_index_type xother_index) const;

  bool lt(const scoped_index& xother_index) const;

  bool lt(const abstract_poset_member* other) const;

  bool ge(pod_index_type xother_index) const;

  bool ge(const scoped_index& xother_index) const;

  bool ge(const abstract_poset_member* other) const;

  bool geqv(pod_index_type xother_index) const;

  bool geqv(const scoped_index& xother_index) const;

  bool gt(pod_index_type xother_index) const;

  bool gt(const scoped_index& xother_index) const;

  bool gt(const abstract_poset_member* other) const;

  bool is_jem(const abstract_poset_member* xother) const;

  abstract_poset_member* greatest_jem() const;

  void greatest_jem_pa( abstract_poset_member* result) const;

  abstract_poset_member* least_jem() const;

  void least_jem_pa( abstract_poset_member* result) const;

  virtual void merge_jem(const abstract_poset_member* xjem);

protected:

private:



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

public: 

  bool covers(const abstract_poset_member* xother) const;

  bool covers(pod_index_type xhub_id) const;

  bool covers(const scoped_index& xid) const;

  virtual void create_cover_link(abstract_poset_member* xlesser);

  virtual void delete_cover_link(abstract_poset_member* lesser);

  index_space_handle& get_cover_id_space(bool xlower) const;

  void release_cover_id_space(index_space_handle& xcover_id_space) const;

  index_space_iterator& get_cover_id_space_iterator(bool xlower) const;

  void release_cover_id_space_iterator(index_space_iterator& xcover_itr) const;

  bool cover_contains_iterator(bool xlower, const index_space_iterator& xitr) const;

  bool cover_is_empty(bool xlower) const;

  bool cover_is_singleton(bool xlower) const;

  virtual size_type cover_ct(bool lower) const;

  bool cover_contains_member(bool xlower, pod_index_type xother_mbr_index) const;

  bool cover_contains_member(bool xlower, const scoped_index& xother_mbr_index) const;

  bool cover_is_equal(bool xlower, pod_index_type xother_mbr_index) const;

  bool cover_is_equal(bool xlower, const scoped_index& xother_mbr_index) const;

  pod_index_type first_cover_member(bool xlower) const;

  void first_cover_member(bool xlower, scoped_index& result) const;

  void insert_cover_member(pod_index_type xother_mbr_index, bool xlower);

  void insert_cover_member(const scoped_index& xother_mbr_index, bool xlower);

  void remove_cover_member(pod_index_type xother_mbr_index, bool xlower);

  void remove_cover_member(const scoped_index& xother_mbr_index, bool xlower);

  void remove_cover_member(index_space_iterator& xitr, bool xlower);

  void clear_cover(bool xlower);

  void copy_cover(bool xlower, pod_index_type xother_mbr_index);

  void copy_cover(bool xlower, const scoped_index& xother_mbr_index);

protected:

private:



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

public: 

  int down_ct() const;

  virtual int down_ct(pod_index_type xfilter_index) const;

  int down_ct(const scoped_index& xfilter_index) const;

  virtual subposet* down() const;

  virtual void down_pa(subposet* result) const;

  void delete_down(bool xdelete_exterior = false,
                   bool xenter_jim_edit_mode = true);

  int up_ct() const;

  virtual int up_ct(pod_index_type xfilter_index) const;

  int up_ct(const scoped_index& xfilter_index) const;

  virtual subposet* up() const;

  virtual void up_pa(subposet* result) const;

  virtual int jim_ct() const;

  virtual subposet* jims();

  virtual void jims_pa(subposet* result);

  virtual int maximal_jim_ct() const;

  virtual subposet* maximal_jims();

  virtual void maximal_jims_pa(subposet* result) const;

  virtual int atom_ct() const;

  virtual subposet* atoms() const;

  virtual void atoms_pa(subposet* result) const;

protected:

private:



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

public: 

  abstract_poset_member* p_join(abstract_poset_member* other) const;

  virtual void p_join_pa(abstract_poset_member* other, abstract_poset_member* result) const;

  void p_join_sa(abstract_poset_member* other);

  abstract_poset_member* p_meet(abstract_poset_member* other);

  virtual void p_meet_pa(abstract_poset_member* other, abstract_poset_member* result);

  void p_meet_sa(abstract_poset_member* other);

protected:

private:



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

public: 

  abstract_poset_member* l_join(abstract_poset_member* other, bool xnew_jem = true);

  void l_join_pa(abstract_poset_member* other, abstract_poset_member* result, bool xnew_jem = true);

  void l_join_sa(abstract_poset_member* other, bool xnew_jem = true);

  abstract_poset_member* l_meet(abstract_poset_member* other, bool xnew_jem = true);

  void l_meet_pa(abstract_poset_member* other, abstract_poset_member* result, bool xnew_jem = true);

  void l_meet_sa(abstract_poset_member* other, bool xnew_jem = true);

  abstract_poset_member* l_not(bool xnew_jem = true) const;
  

  void l_not_pa(abstract_poset_member* result, bool xnew_jem = true) const;

  void l_not_sa(bool xnew_jem = true) const;

protected:

private:



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

public:


  virtual bool is_valid_index(const poset_state_handle* xhost,
                              pod_index_type xhub_id,
                              int xversion = CURRENT_HOST_VERSION) const;

  bool is_valid_index(const poset_state_handle* xhost,
              const scoped_index& xid,
              int xversion = CURRENT_HOST_VERSION) const;

  const index_space_family& id_spaces() const;


  virtual const hub_index_space_handle& hub_id_space() const;

  virtual const scoped_index& hub_id() const;

  virtual scoped_index hub_id(pod_index_type xid) const;

  virtual pod_index_type get_index_from_name(const poset_state_handle* xhost,
                         const std::string& xname) const;

  virtual void get_index_from_name(const poset_state_handle* xhost,
                   const std::string& xname,
                   scoped_index& result) const;

protected:

private:



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

public:


  //   using poset_component::name;

  std::string name() const
  {
    return poset_component::name();
  };

  virtual std::string name(bool xauto_access) const;

  virtual void all_names(block<std::string>& xresult, bool xauto_access = false) const;

  virtual size_type name_ct(bool xauto_access) const;

  virtual bool has_name(const std::string& xname, bool xauto_access = false) const;

  virtual void put_name(const std::string& xname, bool xunique, bool xauto_access);

  virtual void delete_name(const std::string& xname, bool xauto_access = false);

  virtual void delete_all_names(bool xauto_access = false);

protected:

private:



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

public:

  using poset_component::attach_to_state;

  void attach_to_state(const namespace_poset* xns,
                       const poset_path& xpath,
                       bool xauto_access = true);

  void attach_to_state(const namespace_poset* xnamespace,
                       pod_index_type xposet_index,
                       pod_index_type xmember_index,
                       bool xauto_access = true);

  void attach_to_state(const namespace_poset* xnamespace,
                       const scoped_index& xposet_index,
                       const scoped_index& xmember_index,
                       bool xauto_access = true);

  virtual void delete_state(bool xauto_access = false);

protected:

private:



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

public:

  virtual bool is_ancestor_of(const any* other) const;

  virtual abstract_poset_member* clone() const = 0;

  virtual bool invariant() const;

protected:

private:



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

public:

  virtual void to_stream(std::ostream& xos = std::cout) const;

protected:

private:

};


// ===========================================================
// NONMEMBER FUNCTIONS
// ===========================================================

template <typename T>
typename T::table_dofs_type& table_dofs(T& x0);

template <typename T>
const typename T::table_dofs_type& table_dofs(const T& x0);

template <typename T>
typename T::table_dofs_type& table_dofs(T& x0, bool xauto_access);

template <typename T>
const typename T::table_dofs_type& table_dofs(const T& x0, bool xauto_access);

template <typename T>
typename T::row_dofs_type& row_dofs(T& x0);

template <typename T>
const typename T::row_dofs_type& row_dofs(const T& x0);

template <typename T>
typename T::row_dofs_type& row_dofs(T& x0, bool xauto_access);

template <typename T>
const typename T::row_dofs_type& row_dofs(const T& x0, bool xauto_access);
  
SHEAF_DLL_SPEC 
std::ostream& operator << (std::ostream &os, const abstract_poset_member& p);

SHEAF_DLL_SPEC 
std::ostream& operator << (std::ostream &os, const abstract_poset_member* p); 

} // namespace sheaf

#endif // ABSTRACT_POSET_MEMBER_H