scope.cpp

Go to the documentation of this file.

/*
  Scope  -  nested search scope for properties of placement

   Copyright (C)
     2009,            Hermann Vosseler <Ichthyostega@web.de>

  **Lumiera** is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the
  Free Software Foundation; either version 2 of the License, or (at your
  option) any later version. See the file COPYING for further details.

* *****************************************************************/


#include "steam/mobject/session/scope.hpp"
#include "steam/mobject/session/scope-locator.hpp"
#include "steam/mobject/session/query-focus-stack.hpp"
#include "steam/mobject/session/session-service-explore-scope.hpp"
#include "steam/mobject/mobject.hpp"
#include "lib/iter-source.hpp"                 
#include "common/query/query-resolver.hpp"

#include <vector>

using std::string;
using std::vector;
using lib::IterSource;
using lib::iter_source::wrapIter;


namespace lumiera {
namespace error {
  LUMIERA_ERROR_DEFINE (INVALID_SCOPE, "Placement scope invalid and not locatable within model");
  LUMIERA_ERROR_DEFINE (NO_PARENT_SCOPE, "Parent scope of root not accessible");
  LUMIERA_ERROR_DEFINE (EMPTY_SCOPE_PATH, "Placement scope not locatable (empty model path)");
}}

namespace steam {
namespace mobject {
namespace session {
  
  
  
  Scope::Scope (PlacementMO const& constitutingPlacement)
    : anchor_(constitutingPlacement)
  { }
  
  Scope::Scope (PlacementMO::ID const& constitutingPlacement)
    : anchor_(constitutingPlacement)
  { }
  
  
  Scope::Scope ()
    : anchor_()
  {
    REQUIRE (!anchor_.isValid());
  }
  
  
  Scope::Scope (Scope const& o)
    : anchor_(o.anchor_)
  {
    ENSURE (anchor_.isValid());
  }
  
  
  Scope&
  Scope::operator= (Scope const& o)
  {
    anchor_ = o.anchor_;  // note: actually we're just assigning an hash value
    ENSURE (o.isValid());
    return *this;
  }
  
  
  const Scope Scope::INVALID = Scope();
  
  
  
  ScopeLocator::ScopeLocator()
    : focusStack_(new QueryFocusStack)
  { }
  
  ScopeLocator::~ScopeLocator() { }
  
  
  lib::Depend<ScopeLocator> ScopeLocator::instance;
  
  
  lumiera::QueryResolver const&
  ScopeLocator::theResolver()
  {
    return SessionServiceExploreScope::getResolver();
  }
  
  
  size_t
  ScopeLocator::stackSize()  const
  {
    return focusStack_->size();
  }
  
  
  ScopePath&
  ScopeLocator::currPath()
  {
    return focusStack_->top();
  }
  
  
  ScopePath&
  ScopeLocator::pushPath()
  {
    return focusStack_->push (SessionServiceExploreScope::getScopeRoot());
  }
  
  
  IterSource<const Scope>::iterator
  ScopeLocator::locate (Scope const& scope)
  {
    ScopePath& currentPath = focusStack_->top();
    currentPath.navigate (scope);
    return wrapIter (currentPath.begin());
  }
  
  
  
  Scope
  Scope::containing (PlacementMO const& aPlacement)
  {
    return SessionServiceExploreScope::getScope (aPlacement);
  }
  
  
  Scope
  Scope::containing (RefPlacement const& refPlacement)
  {
    return containing (*refPlacement);
  }
  
  
  PlacementMO&
  Scope::getTop()  const
  {
    ASSERT (anchor_);
    return *anchor_;
  }
  
  
  Scope
  Scope::getParent()  const
  {
    if (isRoot())
        throw lumiera::error::Invalid ("can't get parent of root scope"
                                      , LERR_(NO_PARENT_SCOPE));
    
    return SessionServiceExploreScope::getScope (*anchor_);
  }
  
  
  bool
  Scope::isRoot()  const
  {
    return *anchor_ == SessionServiceExploreScope::getScopeRoot();
  }
  
  
  bool
  Scope::isValid()  const
  {
    return anchor_.isValid();
  }
  
  
  Scope::operator string()  const
  {
    string res("[");
    res += anchor_->shortID();
    res += "]";
    return res;
  }
  
  
  
  
  
}}} // namespace steam::mobject::session