crg_interval.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 CRG_INTERVAL_H
#define CRG_INTERVAL_H

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

#ifndef BLOCK_H
#include "SheafSystem/block.h"
#endif

#ifndef PRIMARY_INDEX_SPACE_HANDLE_H
#include "SheafSystem/primary_index_space_handle.h"
#endif

#ifndef SCOPED_INDEX_H
#include "SheafSystem/scoped_index.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 factory;

class poset_state_handle;
class namespace_poset;

// Forward declarations to support friend declaration.

class crg_interval;

std::ostream& operator <<(std::ostream& os, const crg_interval& m);

class SHEAF_DLL_SPEC crg_interval : public any
{

  friend std::ostream& operator <<(std::ostream& os, const crg_interval& m);
  friend SHEAF_DLL_SPEC size_t deep_size(const crg_interval& xp, bool xinclude_shallow);
  friend class poset_crg_state;   // uses cover_name
  
  // ===========================================================
  // ===========================================================

public:

  crg_interval();

  virtual ~crg_interval();

protected:

private:



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

public:

  pod_index_type begin() const;

  void begin(scoped_index& result) const;

  pod_index_type end() const;

  void end(scoped_index& result) const;

  size_type size() const;

  bool contains_member(pod_index_type xindex) const;

  bool contains_member(const scoped_index& xindex) const;

protected:

private:



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

public:

  const index_space_family& id_spaces() const;

  const hub_index_space_handle& hub_id_space() const;

  void initialize_id_spaces(index_space_family& xid_spaces);

  bool id_spaces_initialized() const;

protected:

  index_space_family* _id_spaces;

  bool _id_spaces_initialized;

private:



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

public:

  static std::string local_id_space_name(pod_index_type xindex);

  const primary_index_space_handle& local_id_space() const;

  void initialize_local_id_space(const index_space_handle& xlocal_id_space);

  bool local_id_space_initialized() const;

protected:

  primary_index_space_handle _local_id_space;

  bool _local_id_space_initialized;

private:



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

public:

  pod_index_type cover_id_space_id(bool xlower, pod_index_type xmbr_index) const;

  bool covers_initialized(bool xlower) const;

  void initialize_covers();

protected:

  virtual void initialize_lower_covers() = 0;

  virtual void initialize_upper_covers() = 0;

  pod_index_type _lower_covers_begin;

  bool _lower_covers_initialized;

  pod_index_type _upper_covers_begin;

  bool _upper_covers_initialized;

private:



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

public:

  bool cover_is_explicit(bool xlower, pod_index_type xmbr_index) const;

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

protected:

  static std::string explicit_cover_name(bool xlower, const scoped_index& xmbr_index);

  static std::string explicit_cover_name(bool xlower, pod_index_type xmbr_index);

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

  explicit_cover_map_type _explicit_upper_cover_map;

  explicit_cover_map_type _explicit_lower_cover_map;

  inline explicit_cover_map_type& explicit_cover_map(bool xlower)
  {
    return (xlower ? _explicit_lower_cover_map : _explicit_upper_cover_map);
  };

  inline const explicit_cover_map_type& explicit_cover_map(bool xlower) const
  {
    return (xlower ? _explicit_lower_cover_map : _explicit_upper_cover_map);
  };

private:



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

public:

  static factory<crg_interval>& interval_factory();

  static crg_interval* new_interval(const std::string& xname);

  void initialize(const namespace_poset& xnamespace);

  virtual bool is_initialized() const;

  virtual const std::string& class_name() const;

protected:

private:



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

public:

  virtual bool is_ancestor_of(const any* other) const;

  virtual crg_interval* clone() const = 0;

  virtual bool invariant() const;

protected:

private:

};

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

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

} // namespace sheaf

#endif // ifndef CRG_INTERVAL_H