Naming Convention

Primitive types

PrimitiveType := <PREFIX><DATA_TYPE>

<PREFIX> := ux

<DATA_TYPE> := <BOOL_TYPE> | <NUMERIC_TYPE> | <STRING_TYPE> | <POINTER_TYPE> | <SIZE_TYPE>

<BOOL_TYPE> := bool

<NUMERIC_TYPE> := <BIT_COUNT><TYPE>

    <BIT_COUNT> := 8 | 16 | 32 | 64

    <TYPE> := <INTEGER_TYPE> | <FLOATING_POINT_TYPE>

        <INTEGER_TYPE> := <SIGNED_INTEGER_TYPE> | <UNSIGNED_INTEGER_TYPE>

            <SIGNED_INTEGER_TYPE> := s

            <UNSIGNED_INTEGER_TYPE> := u

        <FLOATING_POINT_TYPE> := f

<STRING_TYPE> := <ENCODE_RESTRICTED_TYPE> | <ENCODE_FREE_TYPE>

    <ENCODE_RESTRICTED_TYPE> := <CHAR_BIT_COUNT> | <CHAR_TYPE>
        <CHAR_BIT_COUNT> := 8 | 16

        <CHAR_TYPE> := <SINGLE_CHAR> | <CHAR_POINTER>
            <SINGLE_CHAR> := c
            <CHAR_POINTER> := <WRITABLE_POINTER> | <CONSTANT_POINTER>
                <WRITABLE_POINTER> := str
                <CONSTANT_POINTER> := cstr
    <ENCODE_FREE_TYPE> := <CHAR_TYPE>

 

<POINTER_TYPE> := ptr<INTEGER_TYPE>

 

<SIZE_TYPE> := size

 

위의 규칙에 따라 아래와 같은 타입들이 정의되어 있다.

// Boolean type definitions
typedef bool uxbool;

// Numeric type definitions
typedef char ux8s;
typedef unsigned char ux8u;
typedef short ux16s;
typedef unsigned short ux16u;
typedef long ux32s;
typedef unsigned long ux32u;
typedef __int64 ux64s;
typedef unsigned __int64 ux64u;
typedef float ux32f;
typedef double ux64f;

// Size type definitions
typedef size_t uxsize;

// Byte-restricted character & string type definitions
typedef char ux8c;
typedef unsigned short ux16c;
typedef char * ux8str;
typedef const char * ux8cstr;
typedef wchar_t * ux16str;
typedef const wchar_t *ux16cstr;

// Pointer type definitions
typedef INT_PTR uxptrs;
typedef UINT_PTR uxptru;

// Byte-freed character & string type definitions
#ifdef _UNICODE
typedef wchar_t uxc;
typedef wchar_t* uxstr;
typedef const wchar_t* uxcstr;
#else
typedef char uxc;
typedef char* uxstr;
typedef const char* uxcstr;
#endif

User-defined type

 

UserDefinedType := <TYPE_CLASSIFIER><USAGE><DELIMITER><CLASS_NAME>

 

<TYPE_CLASSIFIER> := <CLASS> | <INTERFACE> | <TEMPLATE> | <NUMERIC> | <MACRO> | <ENUMERATION> | <STRUCTURE>
    <CLASS> := C
    <INTERFACE> := I
    <TEMPLATE> := T
    <NUMERIC> := N
    <MACRO> := M
    <ENUMERATION> := E
    <STRUCTURE> := S

 

<USAGE> := <CONCRETE_IMPL> | <PARAMETER> | <TYPE_DEFINITION> | <FUNCTION>
    <CONCRETE_IMPL> := U
    <PARAMETER> := P
    <TYPE_DEFINITION> := T
    <FUNCTION> := F

 

<DELIMITER> := x

Typelist (작업 중...)

Typelist

Type을 리스트로 묶는다.

// Definitions of typelist
template <typename TPxTail, typename TPxHead>
class TUxTypeList
{
public:
	typedef TPxHead TTxHead;
	typedef TPxTail TTxTail;
};

 

리스트의 끝을 표현하기 위해서 특별한 타입이 필요하다.

아무런 기능도 없는 클래스이고, 단지 리스트의 끝을 구별하기 위해 사용된다.

class TUxNullType {};

리스트로 묶은 타입들에 대한 정보를 얻는 기능도 필요하다.

// 리스트에 있는 타입의 개수를 얻어오는 기능
template <typename TPxTypeList> class TFxLength;
template <> class TFxLength<TUxNullType>
{
public:
	enum { Value = 0 };
};

template <typename TPxHead, typename TPxTail>
class TFxLength<TUxTypeList<TPxHead,TPxTail>>
{
public:
	enum { Value = 1 + TFxLength<TPxTail>::Value };
};

// 리스트의 특정 위치에 있는 타입을 얻어오는 기능
template <typename TPxTypeList, unsigned int NPxIndex> class TFxTypeAt;

template <typename TPxHead, typename TPxTail>
class TFxTypeAt<TUxTypeList<TPxHead,TPxTail>,0>
{
public:
	typedef TPxHead Type;
};

template <typename TPxHead, typename TPxTail, unsigned int NPxIndex>
class TFxTypeAt<TUxTypeList<TPxHead,TPxTail>,NPxIndex>
{
public:
	typedef typename TFxTypeAt<TPxTail,NPxIndex - 1>::Type Type;
};

// 리스트에서 특정 타입의 인덱스를 얻어오는 기능.
// 만일 같은 타입이 존재한다면 가장 작은 인덱스로 세팅된다.
// 만일 해당 타입이 없다면 -1로 세팅된다.
template <typename TPxTypeList, typename TPxType> class TFxIndexOf;

template <typename TPxType>
class TFxIndexOf<TUxNullType,TPxType>
{
public:
	enum { Index = -1 };
};

template <typename TPxType, typename TPxTail>
class TFxIndexOf<TUxTypeList<TPxType,TPxTail>,TPxType>
{
public:
	enum { Index = 0 };
};

template <typename TPxHead, typename TPxTail, typename TPxType>
class TFxIndexOf<TUxTypeList<TPxHead,TPxTail>,TPxType>
{
private:
	enum { Temp = TFxIndexOf<TPxTail,TPxType>::Index };
public:
	enum { Index = ( Temp == -1 ? -1 : 1 + Temp ) };
};

Typelist를 사용하려면 아래와 같이 typelist가 중첩된 형태로 사용되어야 한다.

// unsigned integer type들을 묶는 typelist 정의
TUxTypeList<unsigned char,TUxTypeList<unsigned short,TUxTypeList<unsigned int,TUxTypeList<unsigned long,TUxNullType>>>>;

Typing하기 귀찮을 뿐더러 알아보기도 어려워 눈알이 뒤통수로 도망가려고 한다.

따라서 아래와 같은 매크로를 만들어 놓으면 사용하기 편하다.

#define TYPELIST_1(T1) TUxTypeList<T1,TUxNullType>
#define TYPELIST_2(T1,T2) TUxTypeList<T1,TYPELIST_1(T2)>
#define TYPELIST_3(T1,T2,T3) TUxTypeList<T1,TYPELIST_2(T2,T3)>
#define TYPELIST_4(T1,T2,T3,T4) TUxTypeList<T1,TypeList_3(T2,T3,T4)>

이하 길이의 매크로는 비슷한 방식으로 노가다로 만들어야 한다.

좀 무식한 방법이긴 하지만 대안이 없다.

 

매크로를 사용하여 unsigned integer typelist를 다시 한번 사용해보자

typedef TYPELIST_4(unsigned char, unsigned short, unsigned int, unsigned long) TTxUnsignedIntegerTypes;

C++ Meta Programming (작업중... 빌어먹을 syntax highlighter)

Meta Programming

 

Compile-Time Assertion

 

Type List

 

Class Generation

Type Set

Typelist는 type들의 중복에 관계 없이 모두 리스트에 담아둔다.

하지만 state machine에서는 동일한 state가 함께 존재하면 안되기 때문에 만약 동일한 타입이 리스트에 존재한다면 무슨일이 있어도 컴파일을 막아야 한다.

현재로서는 심한 야근으로 인해 도저히 머리가 돌아가질 않아 STATIC_ASSERT로 막기로 하고, 후에 더 좋은 아이디어가 떠오르면 업데이트 하도록 한다.

// Typelist에 대한 여러 감사를 수행하는 클래스
template  class TUxTypeListChecker;

// template 파라메터로 typelist가 온 경우
template 
class TUxTypeListChecker>
{
private:
	// 현재 타입이 그 이하의 리스트에 존재하면 1, 그렇지 않으면 0
	enum { CheckCurrList = TUxIndexOf::Index!=-1?1:0};
	// 그 이하의 리스트에 대해 같은 type이 존재하는지 검사
	enum { CheckSubList = TUxTypeListChecker::IsExistSameType };

public:
	// 같은 type이 list에 존재하면 1, 그렇지 않으면 0
	enum { IsExistSameType = (CheckCurrList + CheckSubList) != 0 };
};

// Typelist의 끝에 도달했을 떄
template <> class TUxTypeListChecker
{
public:
	enum { IsExistSameType = 0 };
};

// Type-set 클래스
template 
class TUxTypeSet
{
public:
	typedef TPxTList TList;

public:
	TUxTypeSet( void )
	{
		// Compile assert의 한계로 인해 반드시 함수 안에서 사용되어야 한다.
		// 사용되지 않는 함수는 컴파일타임에 걸러져 assert가 동작하지 않을
		// 수 있기 때문에 생성자에서 사용하는것이 좋다.
		COMPILE_ASSERT::IsExistSameType>();
	}
};

 

 

State Machine

  State Machine Class

    State Class

    Transition Class

      Conditional Transition Selection

  State Manager Class

    State Event(Leave State, Enter State)

    Transition Queue

    State Stack

    Transition Pending

현재 state에서 transition이 불가능하지만 반드시 수행되어야 하는 transition에 대해 특별하게 처리하도록 한다. Transition이 가능한 state에 들어왔을 때 해당 transition 조건에 부합하면 바로 실행하도록 한다.

Extending State Machine

 

Debugging Support

    Transition Stack

        State List: Tick Number

        Transition List: Transition Time & Tick Count

 

Implementation Guide

    Finite State Machine

    Fuzzy State Machine