More similar code is on the official IO CCC website.

http://www.ioccc.org/

http://www.ioccc.org/years.html#2001_herrmann2

So I decided to make SprintfCat(), all the wonderful joy of sprintf, with the ability to concatenate with a already existant string like strcat.

Source code

//
//
size_t ath::SprintfCat( char * inoutBuffer, const size_t inBufferSize, const char * inFormat, ... )
{
	const size_t offset = StrLen( inoutBuffer );
	size_t ret = 0;
	va_list arg;
 
	//
	va_start( arg, inFormat );
	{
		ret = VSprintf( inoutBuffer + offset, inBufferSize - offset, inFormat, arg );
	}
	va_end( arg );
 
	//
	return offset + ret;
}

I had already created my own wrappers around strlen() and vsprintf(), the reason being the fault of Microsoft. With their implementation of the standard library, they decided to deprecate non-safe versions complain at you until you either used their own _s variants, or defined a certain preprocessor.

Source code

//
//
size_t ath::VSprintf( char * outBuffer, const size_t inBufferSize, const char * inFormat, va_list inArgs )
{
#ifndef ATH_PLATFORM_WINDOWS
	return vsnprintf( outBuffer, inBufferSize, inFormat, inArgs );
#else
	return vsprintf_s( outBuffer, inBufferSize, inFormat, inArgs );
#endif
}
 
//
//
size_t ath::StrLen( const char * inString )
{
	return strlen( inString );
}

While I do prefer to have safe versions, their _s variants are not present in the standard and so it makes the code not portable.

I'm still not quite sure about my naming convention for a variable that is an input and an output. While I do like the in or out prefix, I don't think inout looks right, being slightly too long. I wasn't a fan of io either. I have however grown to like the truncation of Athena namespace to ath.

Source code

//
//
#include <assert.h>
 
//
//
template<typename T>
struct AssertPointer
{
	//
	AssertPointer()
		:
		mPointer( NULL )
	{
	}
 
	//
	AssertPointer( T * inPointer )
		:
		mPointer( inPointer )
	{
	}
 
	//
	operator T * ()
	{
		assert( mPointer );
		return mPointer;
	}
 
	//
	operator T * const () const
	{
		assert( mPointer );
		return mPointer;
	}
 
	//
	T * operator -> ()
	{
		assert( mPointer );
		return mPointer;
	}
 
	//
	T * const operator -> () const
	{
		assert( mPointer );
		return mPointer;
	}
 
	//
	T * GetPointerValue()
	{
		return mPointer;
	}
 
	//
	T * const GetPointerValue() const
	{
		return mPointer;
	}
 
private:
	//
	T * mPointer;
};

When declaring your pointer, use the pointer type as the template argument. For example, if you want a pointer to an integer, AssertPointer<int>, or a pointer to an integer pointer, AssertPointer<int *>.

For class or structure pointers, the -> operator is overloaded so you can access its members as you would a normal pointer.

If you need access to the raw pointer value without the assert, just use the GetPointerValue() functions.

I may use it to replace the Delegate structure I created for callbacks in Athena.

Source code

template<typename T, class U = void>
struct Delegate
{
	//
	Delegate()
		:
		func( NULL ),
		object( NULL )
	{
	}
 
	//
	Delegate( T inFunc, U * inObject = NULL )
		:
		func( inFunc ),
		object( inObject )
	{
	}
 
	//
	T func;
	U * object;
};

It is used to store a class object and a function pointer within that class in a single structure. I can use the AssertPointer class and pass the class template type to its template argument, giving me better feedback when I get null pointers being used in my delegates.

I got to writing the unit test for my vector divided by a scalar function when it started to assert. On initial look at the values printed out into the TTY they were both correct, so I extended the precision to 9 and two slightly different values.

TTY

Calculated: 4.059524059
 
Precomputed:  4.059523582
 
Difference: 0.000000477

The values were not that far apart, and I know floating point math can differ for the same value so when comparing usually epsilon gets involved since it is the maximum error. Printing out epsilon, I discovered that the value was just slightly bigger than it making the two numbers different enough.

TTY

Difference: 0.000000477
 
Epsilon: 0.000000119

I could just have my own custom version of epsilon but it would become incorrect for use with smaller and larger number. Or for this case in the unit test I could just use a custom compare, but I wanted something more reusable, and the first google result found me a function.

Relative Floating Point Comparison

bool AlmostEqualRelative2(float A, float B, float maxRelativeError)
{
	if( A == B )
	{
		return true;
	}
 
	float relativeError;
 
	if( fabs(B) > fabs(A) )
	{
		relativeError = fabs((A - B) / B);
	}
	else
	{
		relativeError = fabs((A - B) / A);
	}
 
	if( relativeError <= maxRelativeError )
	{
		return true;
	}
 
	return false;
}

It is a fairly simple one, rather than just comparing the difference to a larger, it determines the relative error and the user passes in a percentage of how large an error it can be.

Although they recommend on the site that you still do not use it, or now it keeps my unit test working allowing me to continue until I have read the rest of the website.

Although I haven't figured out how to reedit pasted code yet, its much faster for inserting code since it adds a button to the visual toolbar. However it does mean all my old code snippets need update with the new one... maybe there is a plugin to do that too.

With the new version of xcode4 it comes with the option to version control source code locally.

However when opening old Xcode3 projects, it does not ask you if you want to add a local repository.

To add one is simple, open up Terminal and navigate to your xcode project folder.

Now enter the following without quotes:

"git init"

"git add ."

Depending on the size of your project folder, it may take a little time before it finishes. Once done, reboot xcode and your project should now be detected by xcode4 as under source control.

I had to recommit all my files before it showed up properly the organiser.

• File Menu
• Source Control > Commit...
• Click Commit

I could use an int rather than the enum variable to get around the problem, but I prefer to be able to see what the enum is set to, so here is the macro to make the code work in non-Microsoft compilers.

Source code

#define ATHENA_START_CSHARP_ENUM( x )	 \
struct x	 			 \
{	 			 \
public:				 \
	enum EnumType
 
#define ATHENA_END_CSHARP_ENUM( x )	 \
	;			 \
				 \
 	inline x()		 \
	{			 \
	}			 \
					 \
	template<typename T>	 \
	inline x( const T & inValue )	 \
		:	 \
		value( (EnumType)inValue )	 \
	{	 \
	}	 \
		\
	inline x( const EnumType inValue )	 \
		:	 \
		value( inValue )	 \
	{	 \
	}	 \
		\
	inline void operator = ( const EnumType inValue )	 \
	{	 \
		value = inValue;	 \
	}	 \
\
	inline EnumType operator ~ () const	 \
	{	 \
		return (EnumType)~value;	 \
	}	 \
\
	inline EnumType operator & ( const EnumType inValue ) const	\
	{	 \
		return (EnumType)( value & inValue );	 \
	}	 \
\
	inline operator EnumType () const	 \
	{	 \
		return value;	 \
	}	 \
\
private:	 \
	EnumType value;	 \
}

Some documentation for pthread_attr_setschedparam() say use PTHREAD_MIN_PRIORITY and PTHREAD_MAX_PRIORITY, however they never seem to exist.

Some sites say use 0 and 31 for them respectively for min and max.

Instead I found a function that will retrieve the min and max priority for a given scheduling policy, allowing you to set the thread priority before it is created.

Source code

void SetAttributeMaxPriority( pthread_attr_t & inThreadAttr )
{
	const int kPolicy = SCHED_RR;
	int minPriority = sched_get_priority_min( kPolicy );
	int maxPriority = sched_get_priority_max( kPolicy );
 
	//
	sched_param schedParam;
	schedParam.sched_priority = maxPriority;
	pthread_attr_setschedparam( &inThreadAttr, &schedParam );
 
	//
	pthread_attr_setschedpolicy( &inThreadAttr, kPolicy );
}

The stack size also needs to be a multiple of the page size, while this is not really an issue unless you go really low or don't use a power of 2 number, I added some code to reinforce it.

Source code

void SetStackSize( pthread_attr_t & inThreadAttr, const int inStackSize )
{
	//
	int stackSize = ( inStackSize < PTHREAD_STACK_MIN ) ? PTHREAD_STACK_MIN : inStackSize;
 
	//
	int pageSize = sysconf( _SC_PAGESIZE );
	if( pageSize == -1 )
	{
		pageSize = PTHREAD_STACK_MIN;
	}
 
	int multipleRemainder = mParams.stackSize % pageSize;
	if( multipleRemainder != 0 )
	{
		stackSize += ( pageSize - multipleRemainder );
	}
 
	//
	pthread_attr_setstacksize( &inThreadAttr, stackSize );
}

I wasn't sure if _SC_PAGESIZE would work on every system, so just incase I made page size equal PTHREAD_STACK_MIN if an error was returned.

Source code

//
if( something && somethingelse )
{
}

You can do this:

Source code

//
if( something and somethingelse )
{
}

There also exists or, xor, and bitwise versions, bitand, bitor.
For more, read the article on the Wikipedia.

But recently I decided to use a more generic unix one sem_t but started having trouble since it failed to create one.

After a bit of changing the code, I found the call to sem_init() always failed, returning an error code on iOS.

The only way I could get it to work was to use sem_open() with the O_CREAT flag.

Source code

//
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <assert.h>
 
//
sem_t * CreateSemaphore( const char * inName, const int inStartingCount )
{
	sem_t * semaphore = sem_open( inName, O_CREAT, 0644, inStartingCount );
 
	//
	if( semaphore == SEM_FAILED )
	{
		switch( errno )
		{
		case EEXIST:
			printf( "Semaphore with name '%s' already exists.\n", inName );
			break;
 
		default:
			printf( "Unhandled error: %d.\n", errno );
			break;
		}
 
		//
		assert(false);
		return SEM_FAILED;
	}
 
	//
	return semaphore;
}

This code however is flawed in that if the semaphore already exists it will use that one instead. So I tried to BitOR the flag O_EXCL to O_CREAT so it asserted if the semaphore existed already.

That worked, however now whenever the app didn't shutdown correctly, the semaphore would not be destroyed and running again would fail since it already existed. I have not yet found a way around this.

Finally to destroy the semaphore, you need to close it with sem_close() instead of sem_destroy().

Source code

//
bool DestroySemaphore( sem_t * inSemaphore )
{
	int retErr = sem_close( inSemaphore );
 
	//
	if( retErr == -1 )
	{
		//
		switch( errno )
		{
		case EINVAL:
			printf( "inSemaphore is not a valid sem_t object." );
			break;
 
		default:
			printf( "Unhandled error: %d.\n", errno );
			break;
		}
 
		//
		assert(false);
		return false;
	}
 
	//
	return true;
}
 
//
void SignalSemaphore( sem_t * inSemaphore )
{
	sem_post( inSemaphore );
}
 
//
void WaitSemaphore( sem_t * inSemaphore )
{
	sem_wait( inSemaphore );
}
 
//
bool TryWaitSemaphore( sem_t * inSemaphore )
{
	int retErr = sem_trywait( inSemaphore );
 
	//
	if( retErr == -1 )
	{
		//
		if( errno != EAGAIN )
		{
			printf( "Unhandled error: %d\n", errno );
			assert( false );
		}
 
		//
		return false;
	}
 
	//
	return true;
}