ISearchFilter filter = new AndFilter(
	new NotFilter(
		new SomeFilter(...)
	),
	new OrFilter(
		new SomeOtherFilter(...),
		new AnotherRandomFilter(...)
	)
);
string str = filter.GetWhatever();

// static creation methods used to avoid 'new', and the resultant parentheses
ISearchFilter filter =
	!Filters.like(...) & (Filters.in(...) | Filters.greaterThan(...))
;
string str = filter.GetWhatever();

using namespace search_builder;

search_filter filter = !like(...) & (in(...) | greater_than(...));

// using () operator in place of GetWhatever()
std::string str = filter();

search_filter filter = !like(...);

namespace search_builder
{
	template <...>
	inline like_filter<...> like(...)
	{
		return like_filter<...>(...);
	}
}

namespace search_builder
{
	// filter<...> is the base type of all filters.  The reason for this is below 
	// this code snippet.
	//
	// The template argument to filter<...> is the type doing the inheriting.
	template <typename FilterT>
	struct not : filter<not<FilterT> >
	{
		not(FilterT const& filter_) : filter(filter_) {}

		// Since a filter is more or less a functional unit, the () operator is 
		// used.  There's really no other reason to do it, except for this 
		// example's eventual use of boost::function<...>.  This operator is 
		// defined in all filters.  In this particular filter, the operator will 
		// manipulate then return the result of this->filter().
		std::string operator()() const
		{
			...
		}

		FilterT filter;
	};

	template <typename FilterT>
	inline not<FilterT> const
	operator ! ( filter<FilterT> const& f )
	{
		return not<FilterT>(f.derived());
	}
}

// Since search_filters themselves must be able to be used in operators, we must wrap 
// boost::function<...> in a type that derives from filter<...>.
struct search_filter : public filter<search_filter>
{
	template <typename F>
	search_filter(filter<F> const& f)
		: embedded(f.derived())
	{}

	std::string operator()() const
	{
		return embedded();
	}

	template <typename F>
	search_filter & operator = (filter<F> const& f)
	{
		embedded = f;
		return *this;
	}

	// The template argument to boost::function is the signature of the function 
	// that we will be using it as.  In this particular case, we give it a function 
	// type that returns a string and takes no arguments.
	boost::function<std::string ()> embedded;
};

// All Records in the Excel Utility take a RecordDataSource in their constructor, so 
// this must be passed when generating records.  For this example, we use a fictional 
// source_t.
std::map<size_t, boost::function<record * (source_t &)> > records_map;
records_map[...] = create<some_record>();
...

template <typename RecordT>
struct create
{
	// Blech!!!
	RecordT * operator()(source_t & source) const
	{
		return new RecordT(source);
	}
};

// records_map[id] returns a function object, that is invoked using the () operator.
// source is the source_t that will be used to create whatever record is associated
// with id.
size_t id = ... ;
record * r = records_map[id](source);

// phoenix::arg1 is a lambda placeholder that will echo the first argument it's given.
records_map[...] = phoenix::new_<some_record>( phoenix::arg1 );
...

boost::any some_obj(int(34));
BOOST_ASSERT(some_obj.type() == typeid(int));

some_obj = my_type();
BOOST_ASSERT(some_obj.type() == typeid(my_type));

some_obj = boost::any();
BOOST_ASSERT(some_obj.empty());
BOOST_ASSERT(some_obj.type() == typeid(void));

// Passing a pointer to boost::any_cast<...>(...) will not throw if the passed any
// pointer doesn't hold the requested type ...
if (int * value = boost::any_cast<int>(&some_obj))
{
	// do something with an integer value
}
else if (my_type * value = boost::any_cast<my_type>(&some_obj))
{
	// do something with a my_type value
}

// ... passing a reference to boost::any_cast<...>(...), however, may throw.
try
{
	int & value = boost::any_cast<int>(some_obj);
}
catch(...)
{
	// some_obj does not hold an int
}

std::map<size_t, boost::function<boost::any ()> > records_map;

records_map[...] = phoenix::construct_<some_record>( /*Constructor arguments.*/ );

namespace detail
{
	template <typename T, typename A0>
	inline T construct(A0 const& a0)
	{
		return T(a0);
	}
}

// If we know what the value is now, we just supply it:
records_map[...] = phoenix::construct_<some_record>( phoenix::arg1, some_value );

// If, however, the value that must be used is to be determined later, we instead pass 
// a reference to a value that may change later ...
records_map[...] = phoenix::construct_<some_record>(
	phoenix::arg1,
	phoenix::var(some_value)
);

// ... or, better yet, we use a Phoenix function object that will determine the value 
// to be used at runtime:
records_map[...] = phoenix::construct_<some_record>(
	phoenix::arg1,
	some_function_object( /*Arguments to be passed, if any.*/ )
);