implicit_entry_map.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 IMPLICIT_ENTRY_MAP_H
#define IMPLICIT_ENTRY_MAP_H

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

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

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

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

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

namespace sheaf
{

template <typename E, typename I> class implicit_entry_map_iterator;
template <typename T> class rc_ptr;

// Forward declarations to enable friend declaration.

template <typename E, typename I> class implicit_entry_map;

template <typename E, typename I>
size_t 
deep_size(const implicit_entry_map<E, I>& xmap, bool xinclude_shallow = true);

template <typename E, typename I>
class SHEAF_DLL_SPEC implicit_entry_map : public any
{

  friend 
  size_t
  deep_size<E, I>(const implicit_entry_map<E, I>& xmap, bool xinclude_shallow);

  friend class implicit_entry_map_iterator<E, I>;
  friend class index_space_family;

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

public:

  typedef pod_index_type pod_type;

  typedef rc_ptr<E> explicit_value_type;

  typedef rc_ptr<I> interval_type;

  typedef implicit_entry_map_iterator<E, I> iterator_type;

  implicit_entry_map();

  ~implicit_entry_map();

  bool contains_explicit_entry(pod_type xid) const;

  bool contains_implicit_entry(pod_type xid) const;

  bool contains_entry(pod_type xid) const;

  E& value(pod_type xid) const;

  E& operator [] (pod_type xid) const;

  void insert_explicit_entry(pod_type xid, E& xvalue);

  void insert_implicit_interval(I& xinterval);

  void remove_explicit_entry(pod_type xid);

  void remove_implicit_interval(pod_type xid);

  void remove_entry(pod_type xid, bool xremove_interval);

  implicit_entry_map_iterator<E, I>* iterator() const;

  pod_type begin() const;

  pod_type end() const;

  size_type ct() const;

protected:

  static const explicit_value_type& null_explicit_value();

  static const interval_type& null_interval();

  const explicit_value_type& explicit_value(pod_type xid) const;

  const interval_type& implicit_interval(pod_type xid) const;

private:

  void update_extrema_for_insert(pod_type xbegin, pod_type xend);

  void update_extrema_for_remove(pod_type xbegin, pod_type xend);

  typedef unordered::unordered_map<pod_type, explicit_value_type*> explicit_value_map_type;

  explicit_value_map_type _explicit_value_map;

  typedef map<pod_type, interval_type*> interval_map_type;

  interval_map_type _interval_map;

  pod_type _begin;

  pod_type _end;

  size_type _ct;



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

public:

  virtual bool is_ancestor_of(const any* other) const;

  virtual implicit_entry_map<E, I>* clone() const;

  virtual bool invariant() const;

protected:

private:


};


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


} // namespace sheaf

#endif // IMPLICIT_ENTRY_MAP_H