The Big Programming Thread - Page 646

	...
	template<class symbolic,class... arg_t>
	struct
		functor_exists
	{
		template<class element,class=void>
		struct
			is_callable
		{ using output=proto<bool,false>; };

		template<class element>
		struct
			is_callable<element,conform<std::result_of_t<jeh::mimic<symbolic,element>(arg_t...)>>>
		{ using output=proto<bool,true>; };

		constexpr bool
			operator()() const 
		{ 
			return 
				not 
				seq::find<
					seq::transform<elements,is_callable>,
					proto<bool,false>
				>(); 
		}
	};

	template<class symbolic,class... arg_t>
	struct	
		functor_return_type
	{ 
		template<class element>
		struct
			_
		{ using output=std::result_of_t<mimic<symbolic,element>(arg_t...)>; };

		using output=typename seq::forward<seq::transform<elements,_>,std::common_type>::type;
	};

	template<class... arg_t>
	inline auto
		operator()(arg_t&&... arg) const& ->
			select_if<
				functor_exists<symbolic_t const&,decltype(std::forward<arg_t>(arg))...>{}(),
				typename functor_return_type<symbolic_t const&,decltype(std::forward<arg_t>(arg))...>::output
			>
	{ return deconstruct([&](const auto& value){ return value(std::forward<arg_t>(arg)...); },*this); }

	template<class... arg_t>
	inline auto
		operator()(arg_t&&... arg) & ->
			select_if<
				functor_exists<symbolic_t&,decltype(std::forward<arg_t>(arg))...>{}(),
				typename functor_return_type<symbolic_t&,decltype(std::forward<arg_t>(arg))...>::output
			>
	{ return deconstruct([&](auto& value){ return value(std::forward<arg_t>(arg)...); },*this); }

	template<class... arg_t>
	inline auto
		operator()(arg_t&&... arg) && ->
			select_if<
				functor_exists<symbolic_t&&,decltype(std::forward<arg_t>(arg))...>{}(),
				typename functor_return_type<symbolic_t&&,decltype(std::forward<arg_t>(arg))...>::output
			>
	{ return deconstruct([&](auto&& value){ return std::move(value)(std::forward<arg_t>(arg)...); },*this); }
	...

final List<ArrayList<Integer>> smallerEdges = new ArrayList<ArrayList<Integer>>(graph.numVertices);
final List<HashSet<Integer>> biggerEdges = new ArrayList<HashSet<Integer>>(graph.numVertices);

String strLine = null;
while ((strLine = graph.bufferedReader.readLine()) != null && !strLine.equals(""))   {
    String parts[] = strLine.split(": ", 2);

    final Integer vertex = Integer.parseInt(parts[0]);

    final ArrayList<Integer> smallEdges = new ArrayList<Integer>();
    final ArrayList<Integer> bigEdges = new ArrayList<Integer>();

    if (parts.length > 1) {
        StringTokenizer tokenizer = new StringTokenizer(parts[1]);

        while (tokenizer.hasMoreTokens()) {
            String token = tokenizer.nextToken();
            final Integer edge = Integer.parseInt(token);
            if (edge < vertex) {
                smallEdges.add(edge);
            } else {
                bigEdges.add(edge);
            }
        }
    }

    Collections.sort(smallEdges);
    Collections.sort(bigEdges);

    smallerEdges.add(new ArrayList<Integer>(smallEdges));
    biggerEdges.add(new LinkedHashSet<Integer>(bigEdges));
}

// step is 1, initialPosition is 0

for (int i = initialPosition; i < smallerEdges.size(); i += step) {
    for (Integer smallVertex : smallerEdges.get(i)) {
        for (Integer bigVertex : biggerEdges.get(i)) {
            if (biggerEdges.get(smallVertex).contains(bigVertex)) {
                triangles.add(new Triangle(smallVertex, i, bigVertex));
            }
        }
    }
}