index_space_family.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 INDEX_SPACE_FAMILY_H
#define INDEX_SPACE_FAMILY_H

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

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

#ifndef EXPLICIT_INDEX_SPACE_COLLECTION_H
#include "SheafSystem/explicit_index_space_collection.h"
#endif

#ifndef HUB_INDEX_SPACE_HANDLE_H
#include "SheafSystem/hub_index_space_handle.h"
#endif

#ifndef INTERVAL_INDEX_SPACE_HANDLE_H
#include "SheafSystem/interval_index_space_handle.h"
#endif

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

#ifndef POD_TYPES_H
#include "SheafSystem/pod_types.h"
#endif

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

namespace sheaf
{

class arg_list;
class explicit_index_space_interval;
class index_space_family;
class index_space_family_iterator;
class index_space_interval;
class index_space_iterator;
class index_space_state;
class scattered_insertion_index_space_handle;
class primary_sum_index_space_state;
class scoped_index;

class SHEAF_DLL_SPEC index_space_family : public any
{
  friend class explicit_index_space_handle;
  friend class explicit_index_space_iterator;
  friend class explicit_index_space_state;
  friend class forwarding_index_space_handle;
  friend class id_space_names_record;
  friend class implicit_index_space_iterator;
  friend class index_space_family_iterator;
  friend class index_space_handle;
  friend class index_space_interval;
  friend class index_space_iterator;
  friend class poset_state_handle; // Uses new_primary_state
  friend class poset_crg_state; // Uses new_primary_state
  friend class primary_sum_index_space_state;
  friend SHEAF_DLL_SPEC size_t deep_size(const index_space_family& xfamily, bool xinclude_shallow);

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

public:

  typedef pod_index_type pod_type;

  index_space_family();

  virtual ~index_space_family();

  std::string name(pod_type xid) const;


  pod_type index(const std::string& xname) const;

  void put_name(pod_type xid, const std::string& xname);

  bool contains(pod_type xid) const;

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

  pod_type begin() const;

  pod_type end() const;

  bool has_only_standard_id_spaces() const;

  void update_standard_id_spaces();

  void clear_id_spaces();

  static size_type& max_rep_ids();

protected:

  index_space_family(const index_space_family& xother) { };

  name_multimap _name_to_index;

  pod_type _end;

  pod_type _standard_end;

private:



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

public:

  void delete_space(pod_type xid);

  void delete_space(const std::string& xname);

  bool is_explicit_interval(pod_type xid);

protected:

  pod_type new_primary_state(size_type xct);

  pod_type new_primary_state(pod_type xid, size_type xct);

  void delete_primary_state(pod_type xid);

  void new_state(const std::string& xname, const std::string& xstate_class_name);

  void delete_state(pod_type xid);

  void insert_interval(index_space_interval& xinterval);

  void delete_interval(pod_type xid);

  const index_space_collection* collection(pod_type xid) const;

  index_space_collection* collection(pod_type xid);

  pod_type reserve_next_explicit_id();

  static size_type explicit_interval_size();

  typedef std::map<pod_type, index_space_interval*> interval_map_type;

  typedef interval_map_type::iterator interval_iterator_type;

  typedef interval_map_type::const_iterator const_interval_iterator_type;

  interval_map_type _intervals;

  explicit_index_space_interval* _explicit_interval;

  pod_type _next_explicit_id;

private:



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

public:

  pod_type new_id();

  pod_type new_id(pod_type xid);

  void delete_id(pod_type xid);

  const hub_index_space_handle& hub_id_space() 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;

  static const std::string& hub_id_space_name();

  bool is_valid_reserved_id(pod_type xid) const;

  const index_space_handle& term_of(pod_type xid) const;

  const index_space_handle& term_of(const scoped_index& xid) const;

  const index_space_handle& last_term() const;

  void extend_last_term(size_type xct);

protected:

  hub_index_space_handle _hub_id_space;

  interval_index_space_handle _gathered_hub_id_space;

private:



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

public:

  size_type ct(const std::string& xname) const;

  size_type ct(pod_type xspace_id) const;

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

  bool is_empty(pod_type xspace_id) const;

  pod_type begin(const std::string& xname) const;

  pod_type begin(pod_type xspace_id) const;

  pod_type end(const std::string& xname) const;

  pod_type end(pod_type xspace_id) const;

  pod_type hub_begin(const std::string& xname) const;

  pod_type hub_begin(pod_type xspace_id) const;

  bool is_gathered(const std::string& xname) const;
    
  bool is_gathered(pod_type xspace_id) const;
    
  bool contains(const std::string& xname, pod_type xid) const;

  bool contains(pod_type xspace_id, pod_type xid) const;

  bool contains(const std::string& xname, const scoped_index& xid) const;

  bool contains(pod_type xspace_id, const scoped_index& xid) const;

  bool contains_hub(const std::string& xname, pod_type xid) const;

  bool contains_hub(pod_type xspace_id, pod_type xid) const;

  bool contains_unglued_hub(const std::string& xname, pod_type xid) const;

  bool contains_unglued_hub(pod_type xspace_id, pod_type xid) const;

  bool contains_glued_hub(const std::string& xname, pod_type xid) const;

  bool contains_glued_hub(pod_type xspace_id, pod_type xid) const;

  bool contains(const std::string& xname, pod_type xid, const scoped_index& xhub_id) const;

  bool contains(pod_type xspace_id, pod_type xid, const scoped_index& xhub_id) const;

  bool contains(const std::string& xname, pod_type xid, pod_type xhub_id) const;

  bool contains(pod_type xspace_id, pod_type xid, pod_type xhub_id) const;

  pod_type pod(const std::string& xname, pod_type xid) const;

  pod_type pod(pod_type xspace_id, pod_type xid) const;

  pod_type pod(const std::string& xname, const scoped_index& xid) const;

  pod_type pod(pod_type xspace_id, const scoped_index& xid) const;

  pod_type hub_pod(const std::string& xname, pod_type xid) const;

  pod_type hub_pod(pod_type xspace_id, pod_type xid) const;

  pod_type unglued_hub_pod(const std::string& xname, pod_type xid) const;

  pod_type unglued_hub_pod(pod_type xspace_id, pod_type xid) const;

  pod_type glued_hub_pod(const std::string& xname, pod_type xid) const;

  pod_type glued_hub_pod(pod_type xspace_id, pod_type xid) const;

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

  bool is_persistent(pod_type xspace_id) const;

protected:

private:



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

public:

  void glue(pod_type xid, pod_type xrep);
  
  void unglue(pod_type xid);
  
  void unglue_all(pod_type xrep_id);

  bool has_gluing() const;

protected:

private:



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

public:

  void new_product_structure(const std::string& xname,
                 const abstract_product_structure& xproduct);

  void new_product_structure(pod_type xspace_id,
                 const abstract_product_structure& xproduct);

  void delete_product_structure(const std::string& xname);

  void delete_product_structure(pod_type xspace_id);

  const abstract_product_structure& product_structure(const std::string& xname) const;

  const abstract_product_structure& product_structure(pod_type xspace_id) const;

  abstract_product_structure& product_structure(const std::string& xname);

  abstract_product_structure& product_structure(pod_type xspace_id);

  template<typename T>
  const T& product_structure(const std::string& xname) const;

  template<typename T>
  const T& product_structure(pod_type xspace_id) const;

  template<typename T>
  T& product_structure(const std::string& xname);

  template<typename T>
  T& product_structure(pod_type xspace_id);

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

  bool has_product_structure(pod_type xspace_id) const;

  template<typename T>
  bool product_structure_conforms_to(const std::string& xname) const;

  template<typename T>
  bool product_structure_conforms_to(pod_type xspace_id) const;

protected:

private:



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

public:

  index_space_handle& get_id_space(const std::string& xname) const;

  index_space_handle& get_id_space(pod_type xspace_id) const;

  template<typename T>
  T& get_id_space(const std::string& xname) const;

  template<typename T>
  T& get_id_space(pod_type xspace_id) const;

  template<typename T>
  bool handle_conforms_to_state(const std::string& xname) const;

  template<typename T>
  bool handle_conforms_to_state(pod_type xspace_id) const;

  void release_id_space(index_space_handle& xid_space) const;

  bool allocated_id_space(const index_space_handle& xid_space) const;

protected:

private:



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

public:

  index_space_iterator& get_id_space_iterator(const std::string& xname) const;

  index_space_iterator& get_id_space_iterator(pod_type xspace_id) const;

  void release_id_space_iterator(index_space_iterator& xitr) const;

  bool allocated_id_space_iterator(const index_space_iterator& xitr) const;

protected:

private:



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

public:

  virtual bool is_ancestor_of(const any *other) const;

  virtual bool invariant() const;

protected:

private:


};

// ===========================================================
// NON-MEMBER FUNCTIONS
// ===========================================================
 
SHEAF_DLL_SPEC 
std::ostream&
operator << (std::ostream &xos, const index_space_family& xfamily);

SHEAF_DLL_SPEC 
size_t deep_size(const index_space_family& xfamily, bool xinclude_shallow = true);
  
} // end namespace sheaf

#endif // ifndef INDEX_SPACE_FAMILY_H