RWTFunctorMap2< Key, S1 > Class Template Reference

Deprecated. A functor map that takes two arguments at invocation time and returns no value. More...

#include <rw/functor/map/RWTFunctorMap2.h>

Inheritance diagram for RWTFunctorMap2< Key, S1 >:

Public Types
typedef unsigned(*	hash_function) (const Key &)
typedef Key	key_type
Public Types inherited from RWTFunctor2< Key, S1 >
typedef void(*	CallerSignature) (Key, S1)
typedef Key	S1Type
typedef S1	S2Type

Public Member Functions
	RWTFunctorMap2 (const RWTFunctorMap2< Key, S1 > &second)
	RWTFunctorMap2 (hash_function hf, size_t size=RW_FUNCTOR_MAP_CAPACITY)
	~RWTFunctorMap2 (void)
bool	add (Key key, RWTFunctor1< S1 > functor)
void	clear (void)
bool	contains (Key key) const
size_t	entries (void) const
bool	find (Key key, RWTFunctor1< S1 > &functor) const
RWTFunctor1< S1 >	getDefault (void) const
void	operator() (Key key, S1 s1) const
RWTFunctorMap2< Key, S1 > &	operator= (const RWTFunctorMap2< Key, S1 > &second)
bool	remove (Key key)
void	resize (size_t size)
void	setDefault (RWTFunctor1< S1 > functor)
Public Member Functions inherited from RWTFunctor2< Key, S1 >
	RWTFunctor2 (const RWTFunctor2< Key, S1 > &second)
	RWTFunctor2 (const RWTFunctor< void(Key, S1)> &second)
	RWTFunctor2 (RWStaticCtor)
	RWTFunctor2 (RWTFunctor2Imp< Key, S1 > *functorImp)
	RWTFunctor2 (void)
	~RWTFunctor2 (void)
RWTFunctor2Imp< Key, S1 > &	body (void) const
RWTFunctor2< Key, S1 > &	operator= (const RWTFunctor2< Key, S1 > &second)
RWTFunctor2< Key, S1 > &	operator= (const RWTFunctor< void(Key, S1)> &second)

Detailed Description

template<class Key, class S1>
class RWTFunctorMap2< Key, S1 >

Deprecated

As of SourcePro 12.5, use RWTValHashMap<Key, RWTFunctor<void(S1)>> instead.

The RWTFunctorMap2 class represents the functor maps that take two arguments at invocation time and return no value. Since one of these argments is the key into the map, the functors held in the map take only one argument, and are RWTFunctor1 functors.

Functor maps allow functors to be grouped together in a key/value table structure. They add functors to the map with a corresponding key of type key_type, used later to invoke the desired functor.

Example

#include <rw/functor/map/RWTFunctorMap2.h>
#include <rw/functor/functor1.h>
#include <rw/cstring.h>
 
// Functions that we want to wrap in functors:
void okButton(RWCString user_data) {
  std::cout << "okButton was pushed, user data is: " << user_data
            << std::endl;
}
void cancelButton(RWCString user_data) {
  std::cout << "cancelButton was pushed, user data is: " << user_data
            << std::endl;
}
 
int main() {
  // Create new 'RWTFunctor1<RWCString>s to be the values
  // in the map.
  RWTFunctor1<RWCString> okFunctor =
      rwtMakeFunctor1((void (*)(RWCString))0, okButton);
  RWTFunctor1<RWCString> cancelFunctor =
      rwtMakeFunctor1((void (*)(RWCString))0, cancelButton);
 
  // Create keys with which to associate the values.
  RWCString okKey = "ok";
  RWCString cancelKey = "cancel";
 
  // Declare a new map. A complete, but empty, instance
  // now exists.
  RWTFunctorMap2<RWCString, RWCString> fmap(RWCString::hash);
 
  // Add something to the map to make it useful.
  fmap.add(okKey, okFunctor);
  fmap.add(cancelKey, cancelFunctor);
 
  // Invoking the map with the key "ok" calls the okButton
  // functor, and passes it the caller data "Fred".
  fmap("ok", "Fred");
 
  // Finally, invoking the map with the key "cancel" calls the
  // cancelButton functor, and passes it the caller data "Barney".
  fmap("cancel", "Barney");
 
  return 0;
}

OUTPUT:

okButton was pushed, user data is: Fred
cancelButton was pushed, user data is: Barney

Member Typedef Documentation

hash_function

template<class Key , class S1 >

typedef unsigned(* RWTFunctorMap2< Key, S1 >::hash_function) (const Key &)

The signature of the hash function.

key_type

template<class Key , class S1 >

typedef Key RWTFunctorMap2< Key, S1 >::key_type

The type of the key.

Constructor & Destructor Documentation

RWTFunctorMap2() [1/2]

template<class Key , class S1 >

RWTFunctorMap2< Key, S1 >::RWTFunctorMap2	(	hash_function	hf,
		size_t	size = RW_FUNCTOR_MAP_CAPACITY )

Constructs an empty map instance. This creates a complete RWTFunctorMap2 instance, but with no entries. The size parameter has a default value of RW_FUNCTOR_MAP_CAPACITY, defined in rw/functor/map/pkgdefs.h.

RWTFunctorMap2() [2/2]

template<class Key , class S1 >

RWTFunctorMap2< Key, S1 >::RWTFunctorMap2

(

const RWTFunctorMap2< Key, S1 > &

second

)

Copy constructor. Constructs a new functor map instance that then shares its representation with the functor map second.

~RWTFunctorMap2()

template<class Key , class S1 >

RWTFunctorMap2< Key, S1 >::~RWTFunctorMap2

(

void

)

Destructor.

Member Function Documentation

add()

template<class Key , class S1 >

bool RWTFunctorMap2< Key, S1 >::add	(	Key	key,
		RWTFunctor1< S1 >	functor )

Adds the specified functor to the functor map with the corresponding key, and returns true. If an entry already exists with an equivalent key, returns false, and the addition fails.

clear()

template<class Key , class S1 >

void RWTFunctorMap2< Key, S1 >::clear

(

void

)

Clears the functor map of all entries.

contains()

template<class Key , class S1 >

bool RWTFunctorMap2< Key, S1 >::contains

(

Key

key

)

const

Returns true if the functor map contains an entry with key equivalent to the given key, otherwise false.

entries()

template<class Key , class S1 >

size_t RWTFunctorMap2< Key, S1 >::entries

(

void

)

const

Returns the number of entries in the functor map.

find()

template<class Key , class S1 >

bool RWTFunctorMap2< Key, S1 >::find	(	Key	key,
		RWTFunctor1< S1 > &	functor ) const

Finds the entry in the functor map with a key equivalent to the given key, and returns it via the reference parameter functor. Returns true if the key is found, otherwise false. If a matching key is not found but a default functor exists, sets the parameter functor to the default functor, and returns false. If no match is found and there is no default functor, throws an RWTHRInternalError exception.

See also

setDefault().

getDefault()

template<class Key , class S1 >

RWTFunctor1< S1 > RWTFunctorMap2< Key, S1 >::getDefault

(

void

)

const

Returns the map's default functor.

See also

setDefault().

operator()()

template<class Key , class S1 >

void RWTFunctorMap2< Key, S1 >::operator()	(	Key	key,
		S1	s1 ) const

Invokes the functor in the map that is associated with a key equivalent to the given key. If there is no matching key, and a default functor has been set, calls the default. If there is no default and no matching key, throws an RWTHRInternalError exception.

operator=()

template<class Key , class S1 >

RWTFunctorMap2< Key, S1 > & RWTFunctorMap2< Key, S1 >::operator=

(

const RWTFunctorMap2< Key, S1 > &

second

)

Assignment operator. Binds this functor map instance to the representation of the second map instance.

remove()

template<class Key , class S1 >

bool RWTFunctorMap2< Key, S1 >::remove

(

Key

key

)

Removes the entry, if it exists, with a key equivalent to the given key, and returns true. If no such entry exists, returns false.

resize()

template<class Key , class S1 >

void RWTFunctorMap2< Key, S1 >::resize

(

size_t

size

)

Changes the size of the map to size. This is an expensive operation, since the entire map must be re-created. Size can be set at construction time via the size parameter of the constructor.

setDefault()

template<class Key , class S1 >

void RWTFunctorMap2< Key, S1 >::setDefault

(

RWTFunctor1< S1 >

functor

)

Sets functor as the default functor. This functor is used when an invalid key is provided to access the functor map.