subposet.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 SUBPOSET_H
#define SUBPOSET_H

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

#ifndef SCATTERED_INSERTION_INDEX_SPACE_HANDLE_H
#include "SheafSystem/scattered_insertion_index_space_handle.h"
#endif

#ifndef STD_UNORDERED_SET_H
#include "SheafSystem/std_unordered_set.h"
#endif

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

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

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

#ifndef SUBPOSET_STATE_H
#include "SheafSystem/subposet_state.h"
#endif

#ifndef ZN_TO_BOOL_H
#include "SheafSystem/zn_to_bool.h"
#endif

namespace sheaf
{

template <typename T> class block;
template <typename T> class depth_first_itr;
class abstract_poset_member;
class depth_first_iterator;
class dof_descriptor_array;
class index_iterator;
class poset;
class poset_member;
class poset_member_iterator;
class primitives_poset_schema;
class section_space_schema_subposet;
class storage_agent;
class subposet_member_iterator;
  
class SHEAF_DLL_SPEC subposet : public poset_component
{

  friend class abstract_poset_member;
  friend class depth_first_iterator;
  template<typename T>
  friend class depth_first_itr; // needs members()
  friend class filtered_depth_first_iterator;
  friend class poset_state_handle;
  friend class postorder_iterator;
  friend class preorder_iterator;
  friend class primitives_poset_schema;
  friend class section_space_schema_subposet;
  friend class storage_agent;
  friend class subposet_names_record;
  friend class id_space_names_record;
  friend class subposet_member_iterator;
  friend SHEAF_DLL_SPEC std::ostream & operator << (std::ostream &os, const subposet& s);

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

public:

  subposet();

  subposet(const subposet& xother, bool xdeep_copy = false);

  // NEW HANDLE, NEW STATE CONSTRUCTORS

  explicit subposet(poset_state_handle* xhost,
            const block<pod_index_type>* xmembers = 0,
            bool xauto_access = true);

  subposet(poset_state_handle* xhost,
       const block<scoped_index>& xmembers,
       bool xauto_access);

  // NEW HANDLE, EXISTING STATE CONSTRUCTORS

  subposet(const poset_state_handle* xhost, pod_index_type xhub_id);

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

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

  ~subposet();

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

  // EXISTING HANDLE, NEW STATE "CONSTRUCTORS"

  virtual void new_state(bool xinitialize = true, bool xauto_access = true);

  virtual void new_state(const block<pod_index_type>& xmembers, bool xauto_access = true);

  virtual void new_state(const block<scoped_index>& xmembers, bool xauto_access = true);

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

  virtual void new_state(poset_state_handle* xhost,
                         const block<pod_index_type>& xmembers,
                         bool xauto_access = true);

  virtual void new_state(poset_state_handle* xhost,
                         const block<scoped_index>& xmembers,
                         bool xauto_access = true);

protected:

private:



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

public:

  const scattered_insertion_index_space_handle& id_space() const;

  scattered_insertion_index_space_handle& id_space();

  virtual scattered_insertion_index_space_handle& new_id_space(const std::string& xstate_class_name);

  virtual bool has_id_space() const;

  bool is_persistent() const;

  void put_is_persistent(bool xvalue);

protected:

  virtual std::string id_space_name() const;

  void attach_id_space();

private:



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

public:

  virtual bool is_dof_subposet() const;

  virtual void put_is_dof_subposet(bool xis_dof_subposet);

  virtual int dof_ct() const;

  virtual void put_dof_ct(int xct);

  virtual dof_descriptor_array* dof_descriptors() const;

  virtual void put_dof_descriptors(const dof_descriptor_array* xoffsets);

protected:

private:



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

public:

  int member_ct() const;

  subposet_member_iterator* member_iterator() const;

  virtual index_iterator indexed_member_iterator() const;

  virtual bool contains_member(pod_index_type xmbr_hub_id) const;

  bool contains_member(const scoped_index& xmbr_id) const;

  bool contains_member(const std::string& xname) const;

  bool contains_members(const block<pod_index_type>& xmbr_hub_ids) const;

  bool contains_members(const block<scoped_index>& xmbr_ids) const;

  bool contains_member(const abstract_poset_member* xmbr) const;

  virtual void insert_member(pod_index_type xmbr_hub_id);

  void insert_member(const scoped_index& xmbr_id);

  virtual void insert_members(const block<pod_index_type>& xmbr_hub_ids);

  virtual void insert_members(const block<scoped_index>& xmbr_ids);

  virtual void insert_member(const abstract_poset_member* xmbr);

  virtual void remove_member(pod_index_type xmbr_hub_id);

  void remove_member(const scoped_index& xmbr_id);

  virtual void remove_member(const abstract_poset_member* xmbr);

protected:

  zn_to_bool* members() const;

  zn_to_bool::word_t* membership() const;

//   ///
//   /// True if all the members of other are also members of this.
//   ///
//   bool includes(const list_cover_set* other) const;

private:



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

public:

  bool is_empty() const;

  void make_empty();

  bool is_equal_to(const subposet* other) const;

  void make_equal_to(const subposet* other);

  bool includes(const subposet* other) const;

  subposet* p_union(const subposet* other);

  void p_union_pa(const subposet* other, subposet* result);

  void p_union_sa(const subposet* other);

  subposet* p_intersection(const subposet* other);

  void p_intersection_pa(const subposet* other, subposet* result);

  void p_intersection_sa(const subposet* other);

  subposet* p_minus(const subposet* other);

  void p_minus_pa(const subposet* other, subposet* result);

  void p_minus_sa(const subposet* other);

  subposet* p_not();

  void p_not_pa(subposet* result);

  void p_not_sa();

protected:

private:



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

public:

  subposet* extremals(bool xmaximals);

  void extremals_pa(bool xmaximals, subposet* result);

  subposet* maximals();

  void maximals_pa(subposet* result);

  subposet* minimals();

  void minimals_pa(subposet* result);

  subposet* down() const;

  void down_pa(subposet* result) const;

  // The down set of this subposet, self-allocated
  // void down_sa();

  subposet* up() const;

  void up_pa(subposet* result) const;

  // The up set of this subposet, self-allocated
  // void up_sa();

  subposet* jims();

  void jims_pa(subposet* result);

  subposet* maximal_jims();

  void maximal_jims_pa(subposet* result);

  subposet* minimal_jims();

  void minimal_jims_pa(subposet* result);

  poset_member* p_join();

  void p_join_pa(abstract_poset_member* result);

  poset_member* p_meet();

  void p_meet_pa(abstract_poset_member* result);

protected:

private:



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

public:

  poset_member* l_join(bool xnew_jem = true);

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

  poset_member* l_join_jims(bool xnew_jem = true);

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

  poset_member* l_meet(bool xnew_jem = true);

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

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;

  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:

  virtual void delete_state(bool xauto_access = false);

protected:

private:



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

public:

  virtual bool is_ancestor_of(const any* other) const;

  virtual subposet* clone() const;

  virtual bool invariant() const;

protected:

private:



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

public:

  void to_stream(std::ostream& os = std::cout);

  std::string to_string();

protected:

private:

};


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

SHEAF_DLL_SPEC
std::ostream & operator << (std::ostream &os, const subposet& s);

size_t
SHEAF_DLL_SPEC
deep_size(const subposet& xsp, bool xinclude_shallow = true);

 
} // namespace sheaf

#endif // ifndef SUBPOSET_H