record_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 RECORD_MAP_H
#define RECORD_MAP_H

#ifndef SHEAF_DLL_SPEC_H
#include "SheafSystem/sheaf_dll_spec.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_STRING_H
#include "SheafSystem/std_string.h"
#endif

namespace sheaf
{
  
// Forward declarations to support friend declaration.

template <typename T1, typename T2>
class record_map;

//template <typename T1, typename T2>
//ostream& operator << (ostream &os, record_map<T1, T2>& p);

template<typename internal_index_type, typename external_index_type>
class record_map
{
  // ===========================================================
  // ===========================================================

public:

  record_map();

  record_map(const record_map& xother);

  record_map& operator=(const record_map& xother);

  virtual ~record_map();

  virtual bool invariant() const;

  external_index_type external_id(internal_index_type xinternal_id) const;

  internal_index_type internal_id(external_index_type xexternal_id) const;

  void put_ids(internal_index_type xinternal_id,
               external_index_type xexternal_id);

  bool internal_ids_sequential() const;

  bool external_ids_sequential() const;

  external_index_type put_internal_id(internal_index_type xinternal_id);

  internal_index_type put_external_id(external_index_type xexternal_id);

  bool contains_internal_id(internal_index_type xint_id) const;

  bool contains_external_id(external_index_type xext_id) const;

  bool operator==(const record_map& xother) const;

  size_type ct() const;

  bool is_empty() const;

  void clear();

  void remove_internal_id(internal_index_type xinternal_id);

  void remove_external_id(external_index_type xexternal_id);

  internal_index_type scratch_internal_id() const;

  void put_scratch_internal_id(internal_index_type xid);

  external_index_type scratch_external_id() const;

  void put_scratch_external_id(external_index_type xid);

  internal_index_type internal_id_ub() const;

  external_index_type external_id_ub() const;

  bool ub_is_max() const;

  typedef typename
  unordered::unordered_map<internal_index_type, external_index_type>::const_iterator const_iterator;

  const_iterator begin() const;

  const_iterator end() const;
  
  void print() const;

  void print(std::ostream& xos,
         const record_map<internal_index_type, external_index_type>& xp) const;

protected:

private:

  typedef unordered::unordered_map<internal_index_type, external_index_type> external_map_type;

  external_map_type _to_external;

  typedef unordered::unordered_map<external_index_type, internal_index_type> internal_map_type;

  internal_map_type _to_internal;

  bool _internal_ids_sequential;

  bool _external_ids_sequential;

  internal_index_type _scratch_internal_id;

  external_index_type _scratch_external_id;

  internal_index_type _internal_id_ub;

  external_index_type _external_id_ub;

  bool _entry_removed;

  void unguarded_put_ids(internal_index_type xinternal_id,
                         external_index_type xexternal_id);


};

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

template<typename internal_index_type, typename external_index_type>
std::ostream&
operator<<(std::ostream& xos, const record_map<internal_index_type, external_index_type>& xp);

 
} // namespace sheaf

#endif // ifndef RECORD_MAP_H