scoped_index.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 SCOPED_INDEX_H
#define SCOPED_INDEX_H

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

#ifndef ASSERT_CONTRACT_H
#include "SheafSystem/assert_contract.h"
#endif

#ifndef ERROR_MESSAGE_H
#include "SheafSystem/error_message.h"
#endif

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

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

#ifndef INDEX_TRAITS_H
#include "SheafSystem/index_traits.h"
#endif

#ifndef NAMESPACE_SCHEMA_MEMBER_INDEX_H
#include "SheafSystem/namespace_schema_member_index.h"
#endif

#ifndef NAMESPACE_MEMBER_INDEX_H
#include "SheafSystem/namespace_member_index.h"
#endif

#ifndef PRIMITIVE_ATTRIBUTES_H
#include "SheafSystem/primitive_attributes.h"
#endif

#ifndef PRIMITIVES_SCHEMA_MEMBER_INDEX_H
#include "SheafSystem/primitives_schema_member_index.h"
#endif

#ifndef STANDARD_DOF_TUPLE_INDEX_H
#include "SheafSystem/standard_dof_tuple_index.h"
#endif

#ifndef STANDARD_MEMBER_INDEX_H
#include "SheafSystem/standard_member_index.h"
#endif

#ifndef STANDARD_SUBPOSET_INDEX_H
#include "SheafSystem/standard_subposet_index.h"
#endif

#ifndef STANDARD_VERSION_INDEX_H
#include "SheafSystem/standard_version_index.h"
#endif

#ifndef STD_IOSTREAM_H
#include "SheafSystem/std_iostream.h"
#endif

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

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

#ifndef STD_LIMITS_H
#include "SheafSystem/std_limits.h"
#endif

namespace sheaf
{

class poset_state_handle;   

struct SHEAF_DLL_SPEC scoped_index_hub_pod
{
  pod_index_type pod;
};
 

class SHEAF_DLL_SPEC scoped_index
{
  // ===========================================================
  // ===========================================================

public:

  typedef pod_index_type pod_type;

  scoped_index()
    : _id_spaces(0),
      _scope_id(invalid_pod()),
      _pod(invalid_pod())
  {
    // Preconditions:

    // Body:

    // Postconditions:

    ensure(invariant());
    ensure(!is_scoped());
    ensure(!is_valid());

    // Exit:

    return;
  };

  scoped_index(const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(invalid_pod())
  {
    // Preconditions:

    require(xid_space.is_attached());

    // Body:

    // Postconditions:

    ensure(invariant());
    ensure(is_scoped());
    ensure(same_scope(xid_space));
    ensure(!is_valid());

    // Exit:

    return;
  };

  scoped_index(const index_space_handle& xid_space, pod_type xpod)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(xpod)
  {
    // Preconditions:

    require(xid_space.is_attached());

    // Body:

    // Postconditions:

    ensure(invariant());
    ensure(is_scoped());
    ensure(same_scope(xid_space));
    ensure(pod() == xpod);

    // Exit:

    return;
  };

  scoped_index(const index_space_handle& xid_space, const scoped_index& xother)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(xid_space.pod(xother))
  {
    // Preconditions:

    require(xid_space.is_attached());
    require(xother.same_id_space_family(xid_space));

    // Body:

    // Postconditions:

    ensure(invariant());
    ensure(is_scoped());
    ensure(same_scope(xid_space));
    ensure( !is_valid() || (*this) ==~ xother);

    // Exit:

    return;
  };

  scoped_index(const scoped_index& xother)
    : _id_spaces(0),
      _scope_id(invalid_pod())
  {
    // Preconditions:

    // Body:

    (*this) = xother;

    // Postconditions:

    ensure(invariant());
    ensure((*this).is_identical_to(xother));

    // Exit:

    return;
  };

  scoped_index(const poset_state_handle& xhost, const std::string& xname);

  scoped_index(pod_type xpod, const poset_state_handle& xhost, const std::string& xname);

  scoped_index(const scoped_index& xother, const poset_state_handle& xhost, const std::string& xname);

  ~scoped_index()
  {
    // Preconditions:

    // Body:

    // Postconditions:

    // Exit:

    return;
  };

  scoped_index& operator=(const scoped_index& xother)
  {
    // Preconditions:

    // Body:

    if(this != &xother)
    {
      if(xother._id_spaces != 0)
      {
    // xother is scoped, clone the scope.

    _id_spaces = xother._id_spaces;
    _scope_id = xother._scope_id;
      }
      else
      {
    // xother is not scoped.

    _id_spaces = 0;
    _scope_id = invalid_pod();
      }

      _pod = xother._pod;
    }

    // Postconditions:

    ensure(invariant());
    ensure((*this).is_identical_to(xother));

    // Exit:

    return *this;
  };

  void put(const index_space_handle& xid_space, pod_type xpod)
  {
    // Preconditions:

    require(xid_space.is_attached());

    // Body:

    _id_spaces = &xid_space.id_spaces();
    _scope_id = xid_space.index();
    _pod = xpod;

    // Postconditions:

    ensure(invariant());
    ensure(pod() == xpod);
    ensure(same_scope(xid_space));

    // Exit:

    return;
  };

  scoped_index hub_id() const
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    scoped_index result(*this);
    result.hub_scope();

    // Postconditions:

    ensure(result.is_hub_scope());

    // Exit:

    return result;
  };

  void hub_scope()
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    if(!is_hub_scope())
    {
      // Map the pod to the hub id space.

      _pod = _id_spaces->hub_pod(_scope_id, _pod);

       // Set the current scope to the hub id space.

      _scope_id = _id_spaces->hub_id_space().index();
    }
    else
    {
      // Already in the hub id space; do nothing.
    }

    // Postconditions:

    ensure(is_hub_scope());

    // Exit:

    return;
  };


  bool invariant() const
  {

    return true;
  };

protected:

private:



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

public:

  void put_scope(const index_space_handle& xid_space)
  {
    // Preconditions:

    require(xid_space.is_attached());

    // Body:

    _id_spaces = &xid_space.id_spaces();
    _scope_id = xid_space.index();

    // Postconditions:

    ensure(same_scope(xid_space));

    // Exit:

    return;
  };

  bool same_scope(const scoped_index& xother) const
  {
    return is_scoped() && (_id_spaces == xother._id_spaces) && (_scope_id == xother._scope_id);
  };

  bool same_scope(const index_space_handle& xid_space) const
  {
    return is_scoped() && (_id_spaces == &xid_space.id_spaces()) && (_scope_id == xid_space.index());
  };

  bool same_id_space_family(const scoped_index& xother) const
  {
    return is_scoped() && xother.is_scoped() &&
      (_id_spaces == xother._id_spaces);
  };

  bool same_id_space_family(const index_space_handle& xid_space) const
  {
    return is_scoped() && (xid_space.is_attached()) &&
      (_id_spaces == &(xid_space.id_spaces()));
  };

  const index_space_family& id_spaces() const
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    // Postconditions:

    // Exit:

    return *_id_spaces;
  };

  pod_type scope_id() const
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    // Postconditions:

    // Exit:

    return _scope_id;
  };

  index_space_handle& get_scope() const
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    // Postconditions:

    // Exit:

    return _id_spaces->get_id_space(_scope_id);
  };

  void release_scope(index_space_handle& xid_space) const
  {
    // Preconditions:

    require(is_scoped());
    require(same_scope(xid_space));

    // Body:

    _id_spaces->release_id_space(xid_space);

    // Postconditions:

    ensure(!xid_space.is_attached());

    // Exit:

    return;
  };

  bool is_hub_scope() const
  {
    return is_scoped() &&
      (_id_spaces->hub_id_space().index() == _scope_id);
  };

  bool in_scope() const
  {
    return is_scoped() && _id_spaces->contains(_scope_id, _pod);
  };

  bool is_scoped() const
  {
    return (_id_spaces != 0) && _id_spaces->contains(_scope_id);
  };

  scoped_index& operator<<(const scoped_index& xother)
  {
    // Preconditions:

    require(is_scoped());
    require(xother.is_scoped());
    
    // Body:

    _pod = _id_spaces->pod(_scope_id, xother.hub_pod());

    // Postconditions:

    ensure( !is_valid() || (*this) ==~ xother);

    // Exit:

    return *this;
  };

  scoped_index& operator>>(scoped_index& xother) const
  {
    // Preconditions:

    require(is_scoped());
    require(xother.is_scoped());
    
    // Body:

    xother._pod = xother._id_spaces->pod(xother._scope_id, this->hub_pod());

    // Postconditions:

    ensure( !xother.is_valid() || (*this) ==~ xother);

    // Exit:

    return xother;
  };

protected:

private:

  const index_space_family* _id_spaces;

  pod_type _scope_id;


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

public:

  const pod_type& pod() const
  {
    return _pod;
  };

  void put_pod(pod_type xpod)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = xpod;

    // Postconditions:

    ensure(pod() == xpod);

    // Exit:

    return;
  };

  static pod_type invalid_pod()
  {
    return invalid_pod_index();
  };

  pod_type hub_pod() const
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    return _id_spaces->unglued_hub_pod(_scope_id, _pod);
  };

  pod_type unglued_hub_pod() const
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    return _id_spaces->unglued_hub_pod(_scope_id, _pod);
  };

  pod_type glued_hub_pod() const
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    return _id_spaces->glued_hub_pod(_scope_id, _pod);
  };

  scoped_index_hub_pod operator~() const
  {
    scoped_index_hub_pod result;
    result.pod = hub_pod();
    return result;
  };
  
  bool operator==(scoped_index_hub_pod xother) const
  {
    return hub_pod() == xother.pod;
  };

  bool operator!=(scoped_index_hub_pod xother) const
  {
    return hub_pod() != xother.pod;
  };

  bool operator<(scoped_index_hub_pod xother) const
  {
    return hub_pod() < xother.pod;
  };

  bool operator<=(scoped_index_hub_pod xother) const
  {
    return hub_pod() <= xother.pod;
  };

  bool operator>(scoped_index_hub_pod xother) const
  {
    return hub_pod() > xother.pod;
  };

  bool operator>=(scoped_index_hub_pod xother) const
  {
    return hub_pod() >= xother.pod;
  };

protected:

private:

  pod_type _pod;



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

public:

  bool is_valid() const
  {
    bool result;

    // Preconditions:

    // Body:

    result = (_pod != invalid_pod());

    // Postconditions:

    // Exit:

    return result;
  };

  void invalidate()
  {

    // Preconditions:

    // Body:

    _pod = invalid_pod();

    // Postconditions:

    ensure(!is_valid());

    // Exit:
  };

  static const scoped_index& INVALID()
  {
    // Preconditions:

    // Body:

    // Default constructor ensures invalid.

    static const scoped_index result;

    // Postconditions:

    ensure(!result.is_valid());

    // Exit:

    return result;
  };

protected:

private:



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

public:

  bool is_identical_to(const scoped_index& xother) const
  {
    bool result;

    // Preconditions:

    // Body:

    result =
      (_pod == xother._pod) &&
      (_id_spaces == xother._id_spaces) &&
      (_scope_id == xother._scope_id);

    // Postconditions:

    // Exit:

    return result;
  };

  bool is_equivalent_to(const scoped_index& xother) const
  {
    bool result;

    // Preconditions:

    require(is_scoped());
    require(xother.is_scoped());

    // Body:


    result = (hub_pod() == xother.hub_pod());

    // Postconditions:

    ensure(is_basic_query);

    // Exit:

    return result;
  };

  bool operator==(const scoped_index& xother) const
  {
    bool result;

    // Preconditions:

    // Body:

    result = is_identical_to(xother);
      
    // Postconditions:

    ensure(is_basic_query);

    // Exit:

    return result;
  };

  bool operator!=(const scoped_index& xother) const
  {
    bool result;

    // Preconditions:

    // Body:

    result = !is_identical_to(xother);

    // Postconditions:

    // Exit:

    return result;
  };

  bool operator<(const scoped_index& xother) const
  {
    // Preconditions:

    require(same_scope(xother));

    // Body:

    bool result = (_pod < xother._pod);

    // Postconditions:

    ensure(is_basic_query);

    // Exit:

    return result;
  };

  bool operator<=(const scoped_index& xother) const
  {
    // Preconditions:

    require(same_scope(xother));

    // Body:

    bool result = (_pod <= xother._pod);

    // Postconditions:

    ensure(is_basic_query);

    // Exit:

    return result;
  };

  bool operator>(const scoped_index& xother) const
  {
    // Preconditions:

    require(same_scope(xother));

    // Body:

    bool result = (_pod > xother._pod);

    // Postconditions:

    ensure(is_basic_query);

    // Exit:

    return result;
  };

  bool operator>=(const scoped_index& xother) const
  {
    // Preconditions:

    require(same_scope(xother));

    // Body:

    bool result = (_pod >= xother._pod);

    // Postconditions:

    ensure(is_basic_query);

    // Exit:

    return result;
  };

  bool in_range(const scoped_index& xbegin, const scoped_index& xend) const
  {
    // Preconditions:

    require(xbegin.same_scope(xend));
    require(same_id_space_family(xbegin));
    
    // Body:

    pod_index_type lpod = xbegin._id_spaces->pod(xbegin._scope_id, this->hub_pod());

    bool result = ((xbegin.pod() <= lpod) && (xend.pod() > lpod));
    
    // Postconditions:

    // Exit:

    return result;
  };

protected:

private:



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

public:

  scoped_index operator+(const scoped_index& xother) const
  {
    // Preconditions:

    // Body:

    scoped_index result(*this);
    result += xother;

    // Postconditions:

    ensure(result.same_scope(*this));
    ensure(result.pod() == (pod() + id_spaces().pod(scope_id(), xother)));

    // Exit:

    return result;
  };


  scoped_index& operator+=(const scoped_index& xother)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    define_old_variable(pod_type old_pod = pod());
    define_old_variable(scoped_index& result = *this);

    _pod += _id_spaces->pod(_scope_id, xother.hub_pod());

    // Postconditions:

    ensure(pod() == (old_pod + id_spaces().pod(scope_id(), xother)));
    ensure(&result == this);

    // Exit:

    return *this;
  };

  scoped_index& operator++()
  {
    // Preconditions:

    require(is_valid());

    // Body:

    define_old_variable(pod_type old_pod = pod());
    define_old_variable(scoped_index& result = *this);

    ++_pod;

    // Postconditions:

    ensure(pod() == (old_pod + 1));
    ensure(&result == this);

    // Exit:

    return *this;
  };

  const scoped_index operator++(int)
  {
    // Preconditions:

    require(is_valid());

    // Body:

    define_old_variable(pod_type old_pod = pod());

    scoped_index result(*this);

    ++_pod;

    // Postconditions:

    ensure(pod() == (old_pod + 1));
    ensure(result.pod() == old_pod);


    // Exit:

    return result;
  };

  scoped_index operator-() const
  {
    scoped_index result;
    result._pod = -_pod;
    return result;
  };

  scoped_index operator-(const scoped_index& xother) const
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    scoped_index result(*this);
    result -= xother;

    // Postconditions:

    ensure(result.pod() == (pod() - id_spaces().pod(scope_id(), xother)));

    // Exit:

    return result;
  };


  scoped_index& operator-=(const scoped_index& xother)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    define_old_variable(pod_type old_pod = pod());
    define_old_variable(scoped_index& result = *this);

    _pod -= _id_spaces->pod(_scope_id, xother.hub_pod());

    // Postconditions:

    ensure(pod() == (old_pod - id_spaces().pod(scope_id(), xother)));
    ensure(&result == this);

    // Exit:

    return *this;
  };

  scoped_index& operator--()
  {
    // Preconditions:

    require(is_valid());

    // Body:

    define_old_variable(pod_type old_pod = pod());
    define_old_variable(scoped_index& result = *this);

    --_pod;

    // Postconditions:

    ensure(pod() == (old_pod - 1));
    ensure(&result == this);

    // Exit:

    return *this;
  };

  const scoped_index operator--(int)
  {
    // Preconditions:

    require(is_valid());

    // Body:

    define_old_variable(pod_type old_pod = pod());

    scoped_index result(*this);

    --_pod;

    // Postconditions:

    ensure(pod() == (old_pod - 1));
    ensure(result.pod() == old_pod);


    // Exit:

    return result;
  };

  scoped_index operator*(const scoped_index& xother) const
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    scoped_index result(*this);
    result *= xother;

    // Postconditions:

    ensure(result.pod() == (pod() * id_spaces().pod(scope_id(), xother)));

    // Exit:

    return result;
  };


  scoped_index& operator*=(const scoped_index& xother)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    define_old_variable(pod_type old_pod = pod());
    define_old_variable(scoped_index& result = *this);

    _pod *= _id_spaces->pod(_scope_id, xother.hub_pod());

    // Postconditions:

    ensure(pod() == (old_pod * id_spaces().pod(scope_id(), xother)));
    ensure(&result == this);

    // Exit:

    return *this;
  };

  scoped_index operator/(const scoped_index& xother) const
  {
    // Preconditions:

    require(xother.pod() != 0);

    // Body:

    scoped_index result(*this);
    result /= xother;

    // Postconditions:

    ensure(result.pod() == (pod() / xother.pod()));

    // Exit:

    return result;
  };


  scoped_index& operator/=(const scoped_index& xother)
  {
    // Preconditions:

    require(is_scoped());
    require(id_spaces().pod(scope_id(), xother) != 0);

    // Body:

    define_old_variable(pod_type old_pod = pod());
    define_old_variable(scoped_index& result = *this);

    _pod /= _id_spaces->pod(_scope_id, xother.hub_pod());

    // Postconditions:

    ensure(pod() == (old_pod / id_spaces().pod(scope_id(), xother)));
    ensure(&result == this);

    // Exit:

    return *this;
  };

  scoped_index operator%(const scoped_index& xother) const
  {
    // Preconditions:

    require(is_scoped());
    require(id_spaces().pod(scope_id(), xother) != 0);

    // Body:

    scoped_index result(*this);
    result %= xother;

    // Postconditions:

    ensure(result.pod() == (pod() % id_spaces().pod(scope_id(), xother)));

    // Exit:

    return result;
  };


  scoped_index& operator%=(const scoped_index& xother)
  {

    // Preconditions:

    require(is_scoped());
    require(id_spaces().pod(scope_id(), xother) != 0);

    // Body:

    define_old_variable(pod_type old_pod = pod());
    define_old_variable(scoped_index& result = *this);

    _pod %= _id_spaces->pod(_scope_id, xother.hub_pod());

    // Postconditions:

    ensure(pod() == (old_pod % id_spaces().pod(scope_id(), xother)));
    ensure(&result == this);

    // Exit:

    return *this;
  };

  bool is_positive() const
  {
    return _pod >= 0;
  };

  bool is_positive_definite() const
  {
    return _pod > 0;
  };

protected:

private:


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

public:

  scoped_index(primitive_type x, const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(x)
  {
    ensure((x == NOT_A_PRIMITIVE_TYPE) == (!is_valid()));
  };

  scoped_index& operator=(primitive_type x)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = x;

    // Postconditions:

    // Exit:

    return *this;
  };

  bool operator==(primitive_type x) const
  {
    return _pod == x;
  };

  bool operator!=(primitive_type x) const
  {
    return _pod != x;
  };

  bool operator<(primitive_type x) const
  {
    return _pod < x;
  };

  bool operator<=(primitive_type x) const
  {
    return _pod <= x;
  };

  bool operator>(primitive_type x) const
  {
    return _pod > x;
  };

  bool operator>=(primitive_type x) const
  {
    return _pod >= x;
  };

protected:

private:



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

public:

  scoped_index(standard_member_index x, const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(x)
  {
    ensure((x == NOT_A_STANDARD_MEMBER_INDEX) == (!is_valid()));
  };

  scoped_index& operator=(standard_member_index x)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = x;

    // Postconditions:

    // Exit:

    return *this;
  };

  bool operator==(standard_member_index x) const
  {
    return _pod == x;
  };

  bool operator!=(standard_member_index x) const
  {
    return _pod != x;
  };

  bool operator<(standard_member_index x) const
  {
    return _pod < x;
  };

  bool operator<=(standard_member_index x) const
  {
    return _pod <= x;
  };

  bool operator>(standard_member_index x) const
  {
    return _pod > x;
  };

  bool operator>=(standard_member_index x) const
  {
    return _pod >= x;
  };

protected:

private:



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

public:

  scoped_index(primitives_schema_member_index x, const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(x)
  {
    ensure((x == NOT_A_PRIMITIVES_SCHEMA_MEMBER_INDEX) == (!is_valid()));
  };

  scoped_index& operator=(primitives_schema_member_index x)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = x;

    // Postconditions:

    // Exit:

    return *this;
  };

  bool operator==(primitives_schema_member_index x) const
  {
    return _pod == x;
  };

  bool operator!=(primitives_schema_member_index x) const
  {
    return _pod != x;
  };

  bool operator<(primitives_schema_member_index x) const
  {
    return _pod < x;
  };

  bool operator<=(primitives_schema_member_index x) const
  {
    return _pod <= x;
  };

  bool operator>(primitives_schema_member_index x) const
  {
    return _pod > x;
  };

  bool operator>=(primitives_schema_member_index x) const
  {
    return _pod >= x;
  };

protected:

private:



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

public:

  scoped_index(namespace_schema_member_index x, const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(x)
  {
    ensure((x == NOT_A_NAMESPACE_SCHEMA_MEMBER_INDEX) == (!is_valid()));
  };

  scoped_index& operator=(namespace_schema_member_index x)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = x;

    // Postconditions:

    // Exit:

    return *this;
  };

  bool operator==(namespace_schema_member_index x) const
  {
    return _pod == x;
  };

  bool operator!=(namespace_schema_member_index x) const
  {
    return _pod != x;
  };

  bool operator<(namespace_schema_member_index x) const
  {
    return _pod < x;
  };

  bool operator<=(namespace_schema_member_index x) const
  {
    return _pod <= x;
  };

  bool operator>(namespace_schema_member_index x) const
  {
    return _pod > x;
  };

  bool operator>=(namespace_schema_member_index x) const
  {
    return _pod >= x;
  };

protected:

private:



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

public:

  scoped_index(namespace_member_index x, const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(x)
  {
    ensure((x == NOT_A_NAMESPACE_MEMBER_INDEX) == (!is_valid()));
  };

  scoped_index& operator=(namespace_member_index x)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = x;

    // Postconditions:

    // Exit:

    return *this;
  };

  bool operator==(namespace_member_index x) const
  {
    return _pod == x;
  };

  bool operator!=(namespace_member_index x) const
  {
    return _pod != x;
  };

  bool operator<(namespace_member_index x) const
  {
    return _pod < x;
  };

  bool operator<=(namespace_member_index x) const
  {
    return _pod <= x;
  };

  bool operator>(namespace_member_index x) const
  {
    return _pod > x;
  };

  bool operator>=(namespace_member_index x) const
  {
    return _pod >= x;
  };

protected:

private:



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

public:

  scoped_index(standard_subposet_index x, const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(x)
  {
    ensure((x == NOT_A_STANDARD_SUBPOSET_INDEX) == (!is_valid()));
  };

  scoped_index& operator=(standard_subposet_index x)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = x;

    // Postconditions:

    // Exit:

    return *this;
  };

  bool operator==(standard_subposet_index x) const
  {
    return _pod == x;
  };

  bool operator!=(standard_subposet_index x) const
  {
    return _pod != x;
  };

  bool operator<(standard_subposet_index x) const
  {
    return _pod < x;
  };

  bool operator<=(standard_subposet_index x) const
  {
    return _pod <= x;
  };

  bool operator>(standard_subposet_index x) const
  {
    return _pod > x;
  };

  bool operator>=(standard_subposet_index x) const
  {
    return _pod >= x;
  };

protected:

private:



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

public:

  scoped_index(standard_version_index x, const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(x)
  {
    ensure((x == NOT_A_STANDARD_VERSION_INDEX) == (!is_valid()));
  };

  scoped_index& operator=(standard_version_index x)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = x;

    // Postconditions:

    // Exit:

    return *this;
  };

  bool operator==(standard_version_index x) const
  {
    return _pod == x;
  };

  bool operator!=(standard_version_index x) const
  {
    return _pod != x;
  };

  bool operator<(standard_version_index x) const
  {
    return _pod < x;
  };

  bool operator<=(standard_version_index x) const
  {
    return _pod <= x;
  };

  bool operator>(standard_version_index x) const
  {
    return _pod > x;
  };

  bool operator>=(standard_version_index x) const
  {
    return _pod >= x;
  };

protected:

private:



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

public:

  scoped_index(standard_dof_tuple_index x, const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(x)
  {
    ensure((x == NOT_A_STANDARD_DOF_TUPLE_INDEX) == (!is_valid()));
  };

  scoped_index& operator=(standard_dof_tuple_index x)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = x;

    // Postconditions:

    // Exit:

    return *this;
  };

  bool operator==(standard_dof_tuple_index x) const
  {
    return _pod == x;
  };

  bool operator!=(standard_dof_tuple_index x) const
  {
    return _pod != x;
  };

  bool operator<(standard_dof_tuple_index x) const
  {
    return _pod < x;
  };

  bool operator<=(standard_dof_tuple_index x) const
  {
    return _pod <= x;
  };

  bool operator>(standard_dof_tuple_index x) const
  {
    return _pod > x;
  };

  bool operator>=(standard_dof_tuple_index x) const
  {
    return _pod >= x;
  };

protected:

private:



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

public:

  scoped_index(unsigned char xother, const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(static_cast<pod_type>(xother))
  {
  };

  scoped_index& operator=(unsigned char xother)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = static_cast<pod_type>(xother);

    // Postconditions:

    // Exit:

    return *this;
  };

  bool operator==(unsigned char xother) const
  {
    return _pod == static_cast<pod_type>(xother);
  };

  bool operator!=(unsigned char xother) const
  {
    return _pod != static_cast<pod_type>(xother);
  };

  bool operator<(unsigned char xother) const
  {
    return _pod < static_cast<pod_type>(xother);
  };

  bool operator<=(unsigned char xother) const
  {
    return _pod <= static_cast<pod_type>(xother);
  };

  bool operator>(unsigned char xother) const
  {
    return _pod > static_cast<pod_type>(xother);
  };

  bool operator>=(unsigned char xother) const
  {
    return _pod >= static_cast<pod_type>(xother);
  };

  scoped_index& operator+=(unsigned char xother)
  {
    _pod += static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator+(unsigned char xother) const
  {
    scoped_index result(*this);
    return result += xother;
  };

  scoped_index& operator-=(unsigned char xother)
  {
    _pod -= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator-(unsigned char xother) const
  {
    scoped_index result(*this);
    return result -= xother;
  };

  scoped_index& operator*=(unsigned char xother)
  {
    _pod *= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator*(unsigned char xother) const
  {
    scoped_index result(*this);
    return result *= xother;
  };

  scoped_index& operator/=(unsigned char xother)
  {
    _pod /= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator/(unsigned char xother) const
  {
    scoped_index result(*this);
    return result /= xother;
  };

  scoped_index& operator%=(unsigned char xother)
  {
    _pod %= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator%(unsigned char xother) const
  {
    scoped_index result(*this);
    return result %= xother;
  };

protected:

private:



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

public:

  scoped_index(unsigned short int xother, const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(static_cast<pod_type>(xother))
  {
  };

  scoped_index& operator=(unsigned short int xother)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = static_cast<pod_type>(xother);

    // Postconditions:

    // Exit:

    return *this;
  };

  bool operator==(unsigned short int xother) const
  {
    return _pod == static_cast<pod_type>(xother);
  };

  bool operator!=(unsigned short int xother) const
  {
    return _pod != static_cast<pod_type>(xother);
  };

  bool operator<(unsigned short int xother) const
  {
    return _pod < static_cast<pod_type>(xother);
  };

  bool operator<=(unsigned short int xother) const
  {
    return _pod <= static_cast<pod_type>(xother);
  };

  bool operator>(unsigned short int xother) const
  {
    return _pod > static_cast<pod_type>(xother);
  };

  bool operator>=(unsigned short int xother) const
  {
    return _pod >= static_cast<pod_type>(xother);
  };

  scoped_index& operator+=(unsigned short int xother)
  {
    _pod += static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator+(unsigned short int xother) const
  {
    scoped_index result(*this);
    return result += xother;
  };

  scoped_index& operator-=(unsigned short int xother)
  {
    _pod -= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator-(unsigned short int xother) const
  {
    scoped_index result(*this);
    return result -= xother;
  };

  scoped_index& operator*=(unsigned short int xother)
  {
    _pod *= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator*(unsigned short int xother) const
  {
    scoped_index result(*this);
    return result *= xother;
  };

  scoped_index& operator/=(unsigned short int xother)
  {
    _pod /= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator/(unsigned short int xother) const
  {
    scoped_index result(*this);
    return result /= xother;
  };

  scoped_index& operator%=(unsigned short int xother)
  {
    _pod %= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator%(unsigned short int xother) const
  {
    scoped_index result(*this);
    return result %= xother;
  };

protected:

private:



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

public:

  scoped_index(unsigned int xother, const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(static_cast<pod_type>(xother))
  {
  };

  scoped_index& operator=(unsigned int xother)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = static_cast<pod_type>(xother);

    // Postconditions:

    // Exit:

    return *this;
  };

  bool operator==(unsigned int xother) const
  {
    return _pod == static_cast<pod_type>(xother);
  };

  bool operator!=(unsigned int xother) const
  {
    return _pod != static_cast<pod_type>(xother);
  };

  bool operator<(unsigned int xother) const
  {
    return _pod < static_cast<pod_type>(xother);
  };

  bool operator<=(unsigned int xother) const
  {
    return _pod <= static_cast<pod_type>(xother);
  };

  bool operator>(unsigned int xother) const
  {
    return _pod > static_cast<pod_type>(xother);
  };

  bool operator>=(unsigned int xother) const
  {
    return _pod >= static_cast<pod_type>(xother);
  };

  scoped_index& operator+=(unsigned int xother)
  {
    _pod += static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator+(unsigned int xother) const
  {
    scoped_index result(*this);
    return result += xother;
  };

  scoped_index& operator-=(unsigned int xother)
  {
    _pod -= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator-(unsigned int xother) const
  {
    scoped_index result(*this);
    return result -= xother;
  };

  scoped_index& operator*=(unsigned int xother)
  {
    _pod *= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator*(unsigned int xother) const
  {
    scoped_index result(*this);
    return result *= xother;
  };

  scoped_index& operator/=(unsigned int xother)
  {
    _pod /= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator/(unsigned int xother) const
  {
    scoped_index result(*this);
    return result /= xother;
  };

  scoped_index& operator%=(unsigned int xother)
  {
    _pod %= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator%(unsigned int xother) const
  {
    scoped_index result(*this);
    return result %= xother;
  };

protected:

private:



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

public:

  scoped_index(unsigned long int xother, const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(static_cast<pod_type>(xother))
  {
  };

  scoped_index& operator=(unsigned long int xother)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = static_cast<pod_type>(xother);

    // Postconditions:

    // Exit:

    return *this;
  };

  bool operator==(unsigned long int xother) const
  {
    return _pod == static_cast<pod_type>(xother);
  };

  bool operator!=(unsigned long int xother) const
  {
    return _pod != static_cast<pod_type>(xother);
  };

  bool operator<(unsigned long int xother) const
  {
    return _pod < static_cast<pod_type>(xother);
  };

  bool operator<=(unsigned long int xother) const
  {
    return _pod <= static_cast<pod_type>(xother);
  };

  bool operator>(unsigned long int xother) const
  {
    return _pod > static_cast<pod_type>(xother);
  };

  bool operator>=(unsigned long int xother) const
  {
    return _pod >= static_cast<pod_type>(xother);
  };

  scoped_index& operator+=(unsigned long int xother)
  {
    _pod += static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator+(unsigned long int xother) const
  {
    scoped_index result(*this);
    return result += xother;
  };

  scoped_index& operator-=(unsigned long int xother)
  {
    _pod -= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator-(unsigned long int xother) const
  {
    scoped_index result(*this);
    return result -= xother;
  };

  scoped_index& operator*=(unsigned long int xother)
  {
    _pod *= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator*(unsigned long int xother) const
  {
    scoped_index result(*this);
    return result *= xother;
  };

  scoped_index& operator/=(unsigned long int xother)
  {
    _pod /= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator/(unsigned long int xother) const
  {
    scoped_index result(*this);
    return result /= xother;
  };

  scoped_index& operator%=(unsigned long int xother)
  {
    _pod %= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator%(unsigned long int xother) const
  {
    scoped_index result(*this);
    return result %= xother;
  };

protected:

private:



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

public:

  scoped_index(signed char xother, const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(static_cast<pod_type>(xother))
  {
  };

  scoped_index& operator=(signed char xother)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = static_cast<pod_type>(xother);

    // Postconditions:

    // Exit:

    return *this;
  };

  bool operator==(signed char xother) const
  {
    return _pod == static_cast<pod_type>(xother);
  };

  bool operator!=(signed char xother) const
  {
    return _pod != static_cast<pod_type>(xother);
  };

  bool operator<(signed char xother) const
  {
    return _pod < static_cast<pod_type>(xother);
  };

  bool operator<=(signed char xother) const
  {
    return _pod <= static_cast<pod_type>(xother);
  };

  bool operator>(signed char xother) const
  {
    return _pod > static_cast<pod_type>(xother);
  };

  bool operator>=(signed char xother) const
  {
    return _pod >= static_cast<pod_type>(xother);
  };

  scoped_index& operator+=(signed char xother)
  {
    _pod += static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator+(signed char xother) const
  {
    scoped_index result(*this);
    return result += xother;
  };

  scoped_index& operator-=(signed char xother)
  {
    _pod -= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator-(signed char xother) const
  {
    scoped_index result(*this);
    return result -= xother;
  };

  scoped_index& operator*=(signed char xother)
  {
    _pod *= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator*(signed char xother) const
  {
    scoped_index result(*this);
    return result *= xother;
  };

  scoped_index& operator/=(signed char xother)
  {
    _pod /= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator/(signed char xother) const
  {
    scoped_index result(*this);
    return result /= xother;
  };

  scoped_index& operator%=(signed char xother)
  {
    _pod %= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator%(signed char xother) const
  {
    scoped_index result(*this);
    return result %= xother;
  };

protected:

private:



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

public:

  scoped_index(short int xother, const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(static_cast<pod_type>(xother))
  {
  };

  scoped_index& operator=(short int xother)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = static_cast<pod_type>(xother);

    // Postconditions:

    // Exit:

    return *this;
  };

  bool operator==(short int xother) const
  {
    return _pod == static_cast<pod_type>(xother);
  };

  bool operator!=(short int xother) const
  {
    return _pod != static_cast<pod_type>(xother);
  };

  bool operator<(short int xother) const
  {
    return _pod < static_cast<pod_type>(xother);
  };

  bool operator<=(short int xother) const
  {
    return _pod <= static_cast<pod_type>(xother);
  };

  bool operator>(short int xother) const
  {
    return _pod > static_cast<pod_type>(xother);
  };

  bool operator>=(short int xother) const
  {
    return _pod >= static_cast<pod_type>(xother);
  };

  scoped_index& operator+=(short int xother)
  {
    _pod += static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator+(short int xother) const
  {
    scoped_index result(*this);
    return result += xother;
  };

  scoped_index& operator-=(short int xother)
  {
    _pod -= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator-(short int xother) const
  {
    scoped_index result(*this);
    return result -= xother;
  };

  scoped_index& operator*=(short int xother)
  {
    _pod *= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator*(short int xother) const
  {
    scoped_index result(*this);
    return result *= xother;
  };

  scoped_index& operator/=(short int xother)
  {
    _pod /= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator/(short int xother) const
  {
    scoped_index result(*this);
    return result /= xother;
  };

  scoped_index& operator%=(short int xother)
  {
    _pod %= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator%(short int xother) const
  {
    scoped_index result(*this);
    return result %= xother;
  };

protected:

private:



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

public:

  scoped_index(int xother, const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(static_cast<pod_type>(xother))
  {
  };

  scoped_index& operator=(int xother)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = static_cast<pod_type>(xother);

    // Postconditions:

    // Exit:

    return *this;
  };

  bool operator==(int xother) const
  {
    return _pod == static_cast<pod_type>(xother);
  };

  bool operator!=(int xother) const
  {
    return _pod != static_cast<pod_type>(xother);
  };

  bool operator<(int xother) const
  {
    return _pod < static_cast<pod_type>(xother);
  };

  bool operator<=(int xother) const
  {
    return _pod <= static_cast<pod_type>(xother);
  };

  bool operator>(int xother) const
  {
    return _pod > static_cast<pod_type>(xother);
  };

  bool operator>=(int xother) const
  {
    return _pod >= static_cast<pod_type>(xother);
  };

  scoped_index& operator+=(int xother)
  {
    _pod += static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator+(int xother) const
  {
    scoped_index result(*this);
    return result += xother;
  };

  scoped_index& operator-=(int xother)
  {
    _pod -= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator-(int xother) const
  {
    scoped_index result(*this);
    return result -= xother;
  };

  scoped_index& operator*=(int xother)
  {
    _pod *= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator*(int xother) const
  {
    scoped_index result(*this);
    return result *= xother;
  };

  scoped_index& operator/=(int xother)
  {
    _pod /= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator/(int xother) const
  {
    scoped_index result(*this);
    return result /= xother;
  };

  scoped_index& operator%=(int xother)
  {
    _pod %= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator%(int xother) const
  {
    scoped_index result(*this);
    return result %= xother;
  };

protected:

private:



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

public:

  scoped_index(long int xother, const index_space_handle& xid_space)
    : _id_spaces(&xid_space.id_spaces()),
      _scope_id(xid_space.index()),
      _pod(static_cast<pod_type>(xother))
  {
  };

  scoped_index& operator=(long int xother)
  {
    // Preconditions:

    require(is_scoped());

    // Body:

    _pod = static_cast<pod_type>(xother);

    // Postconditions:

    // Exit:

    return *this;
  };

  bool operator==(long int xother) const
  {
    return _pod == static_cast<pod_type>(xother);
  };

  bool operator!=(long int xother) const
  {
    return _pod != static_cast<pod_type>(xother);
  };

  bool operator<(long int xother) const
  {
    return _pod < static_cast<pod_type>(xother);
  };

  bool operator<=(long int xother) const
  {
    return _pod <= static_cast<pod_type>(xother);
  };

  bool operator>(long int xother) const
  {
    return _pod > static_cast<pod_type>(xother);
  };

  bool operator>=(long int xother) const
  {
    return _pod >= static_cast<pod_type>(xother);
  };

  scoped_index& operator+=(long int xother)
  {
    _pod += static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator+(long int xother) const
  {
    scoped_index result(*this);
    return result += xother;
  };

  scoped_index& operator-=(long int xother)
  {
    _pod -= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator-(long int xother) const
  {
    scoped_index result(*this);
    return result -= xother;
  };

  scoped_index& operator*=(long int xother)
  {
    _pod *= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator*(long int xother) const
  {
    scoped_index result(*this);
    return result *= xother;
  };

  scoped_index& operator/=(long int xother)
  {
    _pod /= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator/(long int xother) const
  {
    scoped_index result(*this);
    return result /= xother;
  };

  scoped_index& operator%=(long int xother)
  {
    _pod %= static_cast<pod_type>(xother);
    return *this;
  };

  scoped_index operator%(long int xother) const
  {
    scoped_index result(*this);
    return result %= xother;
  };

protected:

private:


};

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

SHEAF_DLL_SPEC
std::ostream& operator<<(std::ostream& xos, const scoped_index& xid);

SHEAF_DLL_SPEC
std::istream& operator>>(std::istream& xis, scoped_index& xid);

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


// =============================================================================
// TEMPLATE SPECIALIZATIONS
// =============================================================================

template <>
struct SHEAF_DLL_SPEC index_traits<scoped_index>
{
  typedef scoped_index index_type;

  typedef index_type::pod_type pod_type;

  static pod_type pod(const index_type& xindex)
  {
    return xindex.pod();
  };

  static void put_pod(index_type& xindex, pod_type& xpod)
  {
    xindex.put_pod(xpod);
    return;
  };

  static index_type invalid()
  {
    return index_type::INVALID();
  };

  static bool is_valid(const index_type& xindex)
  {
    return xindex.is_valid();
  };

  static bool is_positive(const index_type& xindex)
  {
    return xindex.is_positive();
  };

  static bool is_positive_definite(const index_type& xindex)
  {
    return xindex.is_positive_definite();
  };

};
 
} // namespace sheaf

#ifndef SWIG

// Swig doesn't replace preprocessor macros, except to
// process ifdef, ifndef, etc. So the follwoing macro creates
// a syntax error when processed by swig.
// But swig would ignore the namespace and template declaration
// any way, so just don't process it.

SHEAF_BEGIN_UNORDERED_NAMESPACE

template<> struct SHEAF_DLL_SPEC hash<sheaf::scoped_index>
{
  size_t operator()(sheaf::scoped_index xindex) const;
};
 
SHEAF_END_UNORDERED_NAMESPACE

#endif // SWIG


#endif // ifndef SCOPED_INDEX_H