Exercise: Use BOOST_STATIC_ASSERT to add error checking to the binary template presented in section 1.4.1 so that binary<N>::value causes a compilation error if N contains digits other than 0 or 1.

	#include <iostream>
	#include <boost/static_assert.hpp>
	template <unsigned long N>
	struct binary
	{
	BOOST_STATIC_ASSERT(N % 10 < 2);
	static unsigned const value
	= binary<N/10>::value << 1 // prepend higher bits
	| N%10; // to lowest bit
	};
	template <> // specialization
	struct binary<0> // terminates recursion
	{
	static unsigned const value = 0;
	};
	unsigned const one = binary<1>::value;
	unsigned const three = binary<11>::value;
	unsigned const two = binary<10>::value;
	unsigned const five = binary<101>::value;
	unsigned const seven = binary<151>::value;
	unsigned const nine = binary<1001>::value;
	int main()
	{
	std::cout << two << std::endl;
	return 0;
	}

view raw boost_static_assert_exercise.cpp hosted with ❤ by GitHub

boost::mpl addition of physical quantity

This is a demonstration of addition of physical quantities using dimensional analysis:

	#include <boost/mpl/vector_c.hpp>
	#include <iostream>
	typedef boost::mpl::vector_c<int,1,0,0,0,0,0,0> mass;
	typedef boost::mpl::vector_c<int,0,1,0,0,0,0,0> length; // or position
	typedef boost::mpl::vector_c<int,0,0,1,0,0,0,0> time;
	typedef boost::mpl::vector_c<int,0,0,0,1,0,0,0> charge;
	typedef boost::mpl::vector_c<int,0,0,0,0,1,0,0> temperature;
	typedef boost::mpl::vector_c<int,0,0,0,0,0,1,0> intensity;
	typedef boost::mpl::vector_c<int,0,0,0,0,0,0,1> angle;
	template <class T, class Dimensions>
	struct quantity
	{
	explicit quantity(T x)
	: m_value(x)
	{}
	T value() const { return m_value; }
	private:
	T m_value;
	};
	template <class T, class D>
	quantity<T,D>
	operator+(quantity<T,D> x, quantity<T,D> y)
	{
	return quantity<T,D>(x.value() + y.value());
	}
	template <class T, class D>
	quantity<T,D>
	operator-(quantity<T,D> x, quantity<T,D> y)
	{
	return quantity<T,D>(x.value() - y.value());
	}
	int main()
	{
	quantity<float,length> l1( 1.0f );
	quantity<float,length> l2( 2.0f );
	quantity<float,mass> m( 2.0f );
	l1 = l1 + l2;
	// l1 = l1 + m; // error caught at compile-time
	std::cout << l1.value() << std::endl;
	return 0;
	}

view raw mpl_addition.cpp hosted with ❤ by GitHub

boost::mpl equating with dimensions

Equating two physical quantities can only be done if both of them have the same dimensions. For example, a length variable can be equated to another length variable as both of them have the same dimensions (e.g., meters). It is not possible, however, to equate two physical quantities of different dimensions. For example, a mass variable cannot equated to a length variable:

	#include <boost/mpl/vector_c.hpp>
	#include <iostream>
	typedef boost::mpl::vector_c<int,1,0,0,0,0,0,0> mass;
	typedef boost::mpl::vector_c<int,0,1,0,0,0,0,0> length; // or position
	typedef boost::mpl::vector_c<int,0,0,1,0,0,0,0> time;
	typedef boost::mpl::vector_c<int,0,0,0,1,0,0,0> charge;
	typedef boost::mpl::vector_c<int,0,0,0,0,1,0,0> temperature;
	typedef boost::mpl::vector_c<int,0,0,0,0,0,1,0> intensity;
	typedef boost::mpl::vector_c<int,0,0,0,0,0,0,1> angle;
	template <class T, class Dimensions>
	struct quantity
	{
	explicit quantity(T x)
	: m_value(x)
	{}
	T value() const { return m_value; }
	private:
	T m_value;
	};
	int main()
	{
	quantity<float,length> l1( 1.0f );
	quantity<float,length> l2( 2.0f );
	quantity<float,mass> m( 2.0f );
	l1 = l2;
	// l1 = m; // error captured at compile-time
	std::cout << l1.value() << std::endl;
	return 0;
	}

view raw dimensions.cpp hosted with ❤ by GitHub

boost::mpl integral constant wrappers

Am trying to follow this tutorial on boost::mpl

First, I tried this integral constant wrapper:

	#include <iostream>
	#include <boost/mpl/int.hpp>
	int main()
	{
	static int const five = boost::mpl::int_<5>::value;
	std::cout << five << std::endl;
	return 0;
	}

view raw five.cpp hosted with ❤ by GitHub

Guess what it prints out when run. It simply prints "5".

Full configuration

In LTE, there's this thing called full configuration. I guess it's usually used in handovers. During a handover, the source eNodeB informs the target eNodeB about the source eNodeB's enabled features. For instance, the source eNodeB may inform the target eNodeB that it was performing 256QAM with the UE.

Sometimes, however, the target eNodeB does not support the features the source eNodeB was using with the UE. For instance, the source eNodeB may have been previously using 256QAM with the UE, but the target eNodeB may not have support for this feature. When this happens, the target eNodeB may issue a full configuration to the UE. It does this by sending an RRC Connection Reconfiguration message to the UE. This message is first sent to the source eNodeB, then passed as is (without modification) to the UE.

The target eNodeB informs the UE that a full configuration is in progress by sending the fullConfig-r9 information element. During full configuration, the target eNodeB has to resend all information related to bearer setup (as if these bearers were being set up from scratch or for the first time).

In the case of DRB bearers, the DRB-ToAddMod message has to have the following elements present during full configuration:

1. eps-BearerIdentity
2. pdcp-Config
1. discardTimer
2. rlc-AM or rlc-UM (one of them, but not both, has to be present)
3. rlc-Config
4. logicalChannelIdentity
5. logicalChannelConfig