mobject::session::DefsRegistry Class Reference

#include <defsregistry.hpp>

List of all members.

Public Member Functions
template<class TAR>
Iter< TAR >	candidates (const Query< TAR > &query)
	find a sequence of "default" objects possibliy matching the query.
template<class TAR>
string	dump ()
	helper for diagnostics.
template<class TAR>
bool	forget (const P< TAR > &obj)
	if this object is registered as "default" in some way, drop the registration.
template<class TAR>
bool	put (P< TAR > &obj, const Query< TAR > &query)
	register the object as being "default" when searching something similar as designated by the given query.
Private Attributes
Table	table_
Classes
class	Iter
	used for enumerating solutions More...

---

Detailed Description

For internal use only.

Helper for organizing preconfigured default objects. Maintaines a collection of objects known or encountered as "default" for a given type. This collection is ordered by "degree of constriction", which is implemented by counting the number of predicates in the query used to define or identify each object. Accessing an object identified by a query causes the query to be resolved (executed in prolog), which may result in some additional properties of the object being bound or specified.

Todo:

as of 3/2008 the real query implementation is missing, and the exact behaviour has to be defined.

Definition at line 177 of file defsregistry.hpp.

---

Member Function Documentation

template<class TAR>

Iter<TAR> mobject::session::DefsRegistry::candidates

(

const Query< TAR > &

query

)

[inline]

If there was a registration for some object of the given kind with the same query, this one will be first in the sequence. Besides, the sequence will yield all still existing registered "default" objects of this kind, ordered ascending by "degree of constriction", i.e. starting with the object registered togehter with the shortest query.

Returns:

a forward input iterator yielding this sequence

Note:

none of the queries will be evaluated (we're just counting predicates)

Definition at line 239 of file defsregistry.hpp.

          {
            P<TAR> dummy;
            Record<TAR> entry (query, dummy);
            typedef typename Slot<TAR>::Registry Registry;
            Registry& registry = Slot<TAR>::access(table_);
            
            // try to get a possible direct match (same query)
            typename Registry::iterator pos = registry.find (entry);
            typename Registry::iterator end = registry.end();
            
            if (pos==end)
              return Iter<TAR> (registry.begin(), end);        // just ennumerate contents
            else
              return Iter<TAR> (pos, registry.begin(), end); // start with direct match
          }

template<class TAR>

string mobject::session::DefsRegistry::dump

(

)

[inline]

Note:

to use it, your objects need an operator string()

Definition at line 308 of file defsregistry.hpp.

          {
            string res;
            util::for_each ( Slot<TAR>::access(table_)
                           , var(res) += _1
                           );
            return res;
          }

template<class TAR>

bool mobject::session::DefsRegistry::forget

(

const P< TAR > &

obj

)

[inline]

Returns:

false if the object wasn't registered at all.

Definition at line 294 of file defsregistry.hpp.

          {
            typedef typename Slot<TAR>::Registry Registry;
            typedef typename Record<TAR>::Search SearchFunc;
            
            Registry& registry = Slot<TAR>::access(table_);
            return util::remove_if(registry, SearchFunc (obj));
          }

template<class TAR>

bool mobject::session::DefsRegistry::put	(	P< TAR > &	obj,
		const Query< TAR > &	query
	)			[inline]

Only a weak ref is stored.

Parameters:

obj

Will be rebound, if another object is already stored.

Returns:

true if object has actually been stored, false if another object is registered for exactly the same query. In this case, also the param obj shared-ptr is rebound!

Definition at line 265 of file defsregistry.hpp.

          {
            Record<TAR> entry (query, obj);
            typedef typename Slot<TAR>::Registry Registry;
            typedef typename Registry::iterator RIter;
            
            Registry& registry = Slot<TAR>::access(table_);
            RIter pos = registry.lower_bound (entry);
            if (  pos!=registry.end()
               && pos->query == query)
              {
                P<TAR> storedObj (pos->objRef.lock());
                if (storedObj)
                  return (storedObj == obj);
                else
                  // use the opportunity and purge the expired entry
                  registry.erase(pos++);
              }
            // no existing entry....
            registry.insert(pos, entry);
            ENSURE (registry.find (entry) != registry.end());
            return true;
          }

---

The documentation for this class was generated from the following file:

• proc/mobject/session/defsregistry.hpp