poset_crg_state.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 POSET_CRG_STATE_H
#define POSET_CRG_STATE_H

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

#ifndef ANY_H
#include "SheafSystem/any.h"
#endif

#ifndef INDEX_SPACE_FAMILY_H
#include "SheafSystem/index_space_family.h"
#endif

#ifndef NAME_MULTIMAP_H
#include "SheafSystem/name_multimap.h"
#endif

#ifndef POOL_H
#include "SheafSystem/pool.h"
#endif

#ifndef SCOPED_INDEX_H
#include "SheafSystem/scoped_index.h"
#endif

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

#ifndef STD_SET_H
#include "SheafSystem/std_set.h"
#endif

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

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

namespace sheaf
{

class scattered_insertion_index_space_handle;
class index_space_family;
class crg_interval;
class implicit_crg_interval;
class index_space_handle;
class poset_crg_state;
SHEAF_DLL_SPEC size_t deep_size(const poset_crg_state& xp, bool xinclude_shallow, size_t xresults[2]);

class SHEAF_DLL_SPEC poset_crg_state : public any
{

  friend SHEAF_DLL_SPEC size_t deep_size(const poset_crg_state& xp, bool xinclude_shallow, size_t xresults[2]); 
  friend class poset_state_handle;
  friend class poset_state;
  friend class crg_interval; // cover_name
  friend class member_record_set; // explicit_down_set_members
  
  // ===========================================================
  // ===========================================================

public:

  poset_crg_state();

  ~poset_crg_state();

protected:

private:



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

public:

  pod_index_type new_member();
 
  void new_member(pod_index_type xid);

  void new_standard_member_hack(standard_member_index xid);

  pod_index_type new_member_interval(const std::string& xinterval_type, size_type xsize);

  void new_member_interval(pod_index_type xid,
               const std::string& xinterval_type, 
               size_type xsize);

  void delete_member(pod_index_type xid);

  void delete_interval(pod_index_type xid);

  size_type member_ct() const;

  size_type standard_member_ct();

  size_type standard_member_ct() const;

  void put_standard_member_ct(size_type xct);

  const scoped_index& begin() const;

  const scoped_index& end() const;

  bool contains_member(pod_index_type xid) const;

  bool contains_implicit_member(pod_index_type xid) const;

  bool contains_explicit_member(pod_index_type xid) const;

  const crg_interval& interval(pod_index_type xid) const;

  crg_interval& interval(pod_index_type xid);

  implicit_crg_interval* implicit_member(pod_index_type xid) const;

protected:

  void initialize_member_covers(pod_index_type xid, bool xstandard_member_hack = false);

private:

  scoped_index _begin;

  scoped_index _end;  

  size_type _member_ct;

  size_type _standard_member_ct;



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

public:

  const index_space_family& id_spaces() const;

  const hub_index_space_handle& hub_id_space() const;

  const scoped_index& hub_id() const;

  scoped_index hub_id(pod_index_type xid) const;

  const index_space_handle& new_gathered_hub_id_space(bool xexclude_bottom);

  void update_gathered_hub_id_space();

  const index_space_handle& gathered_hub_id_space() const;

  bool has_gathered_hub_id_space() const;

  bool gathered_hub_id_space_excludes_bottom() const;

protected:

private:

  index_space_family _id_spaces;



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

public:

  typedef name_multimap member_name_map_type;

  member_name_map_type& member_name_map();

  const member_name_map_type& member_name_map() const;

protected:

private:

  member_name_map_type _member_name_map;



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

public:

  bool jim_edit_mode() const;

  void request_jim_edit_mode();

  void release_jim_edit_mode();

  int jim_edit_depth() const;

protected:

private:

  int _jim_edit_depth;



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

public:

  bool cover_is_explicit(bool xlower, pod_index_type xmbr_index) const;

  bool cover_is_implicit(bool xlower, pod_index_type xmbr_index) const;

  pod_index_type cover_id_space_id(bool xlower, pod_index_type xmbr_index) const;

  index_space_handle& get_cover_id_space(bool xlower, pod_index_type xmbr_index) const;

  template <typename handle_type>
  handle_type& get_cover_id_space(bool xlower, pod_index_type xmbr_index) const;

  template<typename handle_type>
  bool cover_id_space_handle_conforms_to(bool xlower, pod_index_type xmbr_index) const;

  void release_cover_id_space(index_space_handle& xcover_id_space) const;

  index_space_iterator& get_cover_id_space_iterator(bool xlower, pod_index_type xmbr_index) const;

  void release_cover_id_space_iterator(index_space_iterator& xcover_itr) const;

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

  bool cover_is_empty(bool xlower, pod_index_type xmbr_index) const;

  bool cover_is_singleton(bool xlower, pod_index_type xmbr_index) const;

  size_type cover_ct(bool xlower, pod_index_type xmbr_index) const;

  bool cover_contains_member(bool xlower,
                             pod_index_type xmbr_index,
                             pod_index_type xother_mbr_index) const;

  bool cover_is_equal(bool xlower,
                      pod_index_type xmbr_index,
                      pod_index_type xother_mbr_index) const;

  pod_index_type first_cover_member(bool xlower, pod_index_type xmbr_index) const;

  void insert_cover_member(pod_index_type xother_mbr_index,
                           bool xlower,
                           pod_index_type xmbr_index);

  void insert_cover_member(pod_index_type xother_mbr_index,
                           bool xlower,
                           pod_index_type xmbr_index,
                           index_space_iterator& xitr);

  void remove_cover_member(pod_index_type xother_mbr_index,
                           bool xlower,
                           pod_index_type xmbr_index);

  void remove_cover_member(index_space_iterator& xitr,
                           bool xlower,
                           pod_index_type xmbr_index);

  template <typename filter_type>
  void remove_cover_members(const filter_type& xfilter,
                bool xlower,
                pod_index_type xmbr_index);

  void replace_cover_member(pod_index_type xold_other_mbr_index,
                pod_index_type xnew_other_mbr_index,
                bool xlower,
                pod_index_type xmbr_index);

  void clear_cover(bool xlower, pod_index_type xmbr_index);

  void copy_cover(bool xlower,
                  pod_index_type xmbr_index,
                  pod_index_type xother_mbr_index);

  void append_upper_cover_of_bottom(pod_index_type xmbr_begin,
                    pod_index_type xmbr_end);

protected:

  pod_index_type force_explicit_cover(bool xlower,
                      pod_index_type xmbr_index,
                      bool xinitialize = true);

private:

  typedef unordered::unordered_map<pod_index_type, pod_index_type> explicit_dof_tuple_map_type;

  explicit_dof_tuple_map_type _explicit_dof_tuple_map;

  typedef std::map<pod_index_type, crg_interval*> interval_map_type;

  interval_map_type _interval_map;



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

public:

  pod_index_type member_dof_tuple_id(pod_index_type xmbr_index) const;

  void put_member_dof_tuple_id(pod_index_type xmbr_index,
                               pod_index_type xdof_tuple_id);

protected:

private:



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

public:

  void clean_cover(bool xlower, pod_index_type xmbr_index);

  void explicit_down_set_members(const implicit_crg_interval& xinterval,
                 std::set<pod_index_type>& result) const;

protected:

  void explicit_down_set_members(pod_index_type xmbr_index,
                 std::set<pod_index_type>& result) const;

private:



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

public:

  virtual bool is_ancestor_of(const any* other) const;

  virtual poset_crg_state* clone() const;

  virtual bool invariant() const;

protected:

private:


};

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

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

SHEAF_DLL_SPEC size_t deep_size(const sheaf::poset_crg_state& xp, bool xinclude_shallow = true, size_t xresults[2] = 0);

} // namespace sheaf 



#endif // ifndef POSET_CRG_STATE_H