Description

Pseudo exception mechanism is provided as the static_exception class.

template <typename T>
class static_exception {
  public:
    T const& static_catch(Void) const;
  protected:
    Bool static_try(Void) const;
    Void static_throw(static_exception<T> const& param);
    Void static_throw(T const& param);
};

The above pseudo exception mechanism can be used in the classes such as SFCApplication or SFRApplication, which are derived from the static_exception<T> class.

Example

class MyApp : public SFCApplication {
  SFMSEALCOPY(MyApp)
  private:
    Void SubFunc(Void) static_throws;
    SFCError MyAllocation(Void) { ... }  // function where errors might occur
  public:
    Void MainFunc(Void);
  ...
};

Void SubFunc(Void) static_throws
{
  // confirm current error
  if (static_try()) {  
    // when no error is set
    static_throw(MyAllocation());  // set error
  }
  ...
}

Void MainFunc(Void)
{
  ...
  SubFunc();
  switch (static_catch()) {
    // error handling
    ...
  }
  ...
}

Description

The SFMTYPEDEFBASE macro takes the type name as an argument, and generates the following type declarations.

typedef Base&    BaseRef;
typedef Base*    BasePtr;
typedef Base**   BaseHandle;

Description

The SFMTYPEDEFVOLATILE macro takes the type name as an argument, and generates the following type declarations.

typedef Base volatile    BaseVolatile;
typedef BaseVolatile&    BaseVolatileRef;
typedef BaseVolatile*    BaseVolatilePtr;
typedef BaseVolatile**   BaseVolatileHandle;

Description

The SFMTYPEDEFCONST macro takes the type name as an argument, and generates the following type declarations.

typedef Base const    BaseConst;
typedef BaseConst&    BaseConstRef;
typedef BaseConst*    BaseConstPtr;
typedef BaseConst**   BaseConstHandle;

Description

The SFMTYPEDEFVOLATILECONST macro takes the type name as an argument, and generates the following type declarations.

typedef Base volatile const   BaseVolatileConst;
typedef BaseVolatileConst&    BaseVolatileConstRef;
typedef BaseVolatileConst*    BaseVolatileConstPtr;
typedef BaseVolatileConst**   BaseVolatileConstHandle;

Description

The SFMTYPEDEFPACK macro takes the type name as an argument, and declares the types equivalent to the following macros.

SFMTYPEDEFBASE(Base)
SFMTYPEDEFVOLATILE(Base)
SFMTYPEDEFCONST(Base)
SFMTYPEDEFVOLATILECONST(Base)

Description

The SFMTYPEDEFTYPE macro takes the type name as an argument, and declares the types equivalent to the following macros.

SFMTYPEDEFPACK(Base)
SFMTYPEDEFPACK(BasePtr)
SFMTYPEDEFPACK(BaseHandle)

Description

The SFMTYPEDEFALIAS macro takes the type name and its alias as arguments, and declares the types equivalent to the following macros.

typedef Type   Alias;
SFMTYPEDEFTYPE(Alias);

Description

The SFMTYPEDEFCLASS macro takes the class name as an argument, and declares the types equivalent to the following macros.

class Class;
SFMTYPEDEFTYPE(Class);

Example

SFMTYPEDEFCLASS(A)
class A {
  ...
}

Example for Macro Expansion

The SFMTYPEDEFTYPE macro is expanded as follows:

SFMTYPEDEFCLASS(MyClass);
class MyClass {
private:
  ...
};

class MyClass;
typedef MyClass&                  MyClassRef;
typedef MyClass*                  MyClassPtr;
typedef MyClass**                 MyClassHandle;
typedef MyClass volatile          MyClassVolatile;
typedef MyClass volatile&         MyClassVolatileRef;
typedef MyClass volatile*         MyClassVolatilePtr;
typedef MyClass volatile**        MyClassVolatileHandle;
typedef MyClass const             MyClassConst;
typedef MyClass const&            MyClassConstRef;
typedef MyClass const*            MyClassConstPtr;
typedef MyClass const**           MyClassConstHandle;
typedef MyClass volatile const    MyClassVolatileConst;
typedef MyClass volatile const&   MyClassVolatileConstRef;
typedef MyClass volatile const*   MyClassVolatileConstPtr;
typedef MyClass volatile const**  MyClassVolatileConstHandle;
typedef (MyClass*)&               MyClassPtrRef;
typedef (MyClass*)*               MyClassPtrPtr;
typedef (MyClass*)**              MyClassPtrHandle;
typedef MyClass* volatile         MyClassPtrVolatile; 
typedef MyClass* volatile&        MyClassPtrVolatileRef;
typedef MyClass* volatile*        MyClassPtrVolatilePtr;
typedef MyClass* volatile**       MyClassPtrVolatileHandle;
typedef MyClass* const            MyClassPtrConst;
typedef MyClass* const&           MyClassPtrConstRef;
typedef MyClass* const*           MyClassPtrConstPtr;
typedef MyClass* const**          MyClassPtrConstHandle;
typedef MyClass* volatile const   MyClassPtrVolatileConst;
typedef MyClass* volatile const&  MyClassPtrVolatileConstRef;
typedef MyClass* volatile const*  MyClassPtrVolatileConstPtr;
typedef MyClass* volatile const** MyClassPtrVolatileConstHandle;
typedef (MyClass**)&              MyClassHandleRef;
typedef (MyClass**)*              MyClassHandlePtr;
typedef (MyClass**)**             MyClassHandleHandle;
typedef MyClass** volatile        MyClassHandleVolatile;
typedef MyClass** volatile&       MyClassHandleVolatileRef;
typedef MyClass** volatile*       MyClassHandleVolatilePtr;
typedef MyClass** volatile**      MyClassHandleVolatileHandle;
typedef MyClass** const           MyClassHandleConst;
typedef MyClass** const&          MyClassHandleConstRef;
typedef MyClass** const*          MyClassHandleConstPtr;
typedef MyClass** const**         MyClassHandleConstHandle;
typedef MyClass** volatile const  MyClassHandleVolatileConst;
typedef MyClass** volatile const& MyClassHandleVolatileConstRef;
typedef MyClass** volatile const* MyClassHandleVolatileConstPtr;
typedef MyClass** volatile const**MyClassHandleVolatileConstHandle;

class MyClass {
private:
  ...
};

Description

The SFMTYPEDEFWRAPPER macro takes the class name as an argument, and declares the types equivalent to the following macros.

SFMTYPEDEFCLASS(Class)
SFMTYPEDEFALIAS(SFXBrewPointer<Class>, Class##Smp)
SFMTYPEDEFALIAS(SFXBrewPointer<Class volatile>, Class##VolatileSmp)
SFMTYPEDEFALIAS(SFXBrewPointer<Class const>, Class##ConstSmp)
SFMTYPEDEFALIAS(SFXBrewPointer<Class volatile const>, Class##VolatileConstSmp)

Description

The SFMTYPEDEFRESPONDER macro takes the class name as an argument, and declare the types equivalent to the following macros.

SFMTYPEDEFCLASS(Class)
SFMTYPEDEFALIAS(SFXResponderPointer<Class>, Class##Smp)
SFMTYPEDEFALIAS(SFXResponderPointer<Class volatile>, Class##VolatileSmp)
SFMTYPEDEFALIAS(SFXResponderPointer<Class const>, Class##ConstSmp)
SFMTYPEDEFALIAS(SFXResponderPointer<Class volatile const>, Class##VolatileConstSmp)

Description

The SFMTYPEDEFREFOBJECT macro takes the class name as an argument, and declare the types equivalent to the following macros.

SFMTYPEDEFCLASS(Class)
SFMTYPEDEFALIAS(SFXRefObjectPointer<Class>, Class##Smp)
SFMTYPEDEFALIAS(SFXRefObjectPointer<Class volatile>, Class##VolatileSmp)
SFMTYPEDEFALIAS(SFXRefObjectPointer<Class const>, Class##ConstSmp)
SFMTYPEDEFALIAS(SFXRefObjectPointer<Class volatile const>, Class##VolatileConstSmp)

Description

The SFMTYPEDEFSTRUCT macro takes the structure name as an argument, and declare the types equivalent to the following macros.

struct Struct;
SFMTYPEDEFTYPE(Struct);

Description

The SFMTYPEDEFUNION macro takes the union name as an argument, and declares the types equivalent to the following macros.

union Union;
SFMTYPEDEFTYPE(Union);

Description

This macro takes a class name or a structure name as an argument and then generates the declaration of the implicit type conversion operator from the AtomRec struct into its corresponding class or structure as below.

operator Class&(void);
operator Class const&(void) const;

AtomRec struct

The AtomRec struct is the POD(Plain Old Data) struct in C language which has the same memory layout with the corresponding class or structure. For more details, see Optimize ARM RealView Compilation Tool for BREW(at the Sophia Cradle Web site). If you define the AtomRec struct for a class or structure, you can optimize class or structure initialization with regard to size and speed. In this case, you must not use virtual function, multiple inheritance, and virtual inheritance for the class where the AtomRec struct is defined. To use the AtomRec struct, you have to implement the implicit type conversion operator from the AtomRec struct into the class or structure with the SFMUTILITYATOMDECLARE macro and the SFMUTILITYATOMIMPLEMENT macro, and the mutual type conversion function between the AtomRec struct and its corresopnding class or structure (atomic_cast operator) with SFMUTILITYATOMICCASTDECLARE macro and SFMUTILITYATOMICCASTIMPLEMENT macro. The AtomRec struct is used in SFXEvent, SFXEventRange, and classes of Shape and Color.

	Caution
	When you use the SFMUTILITYATOMDECLARE for declaration macro, you also have to use the SFMUTILITYATOMIMPLEMENT macro for implementation.

In general, this macro is used together with the SFMUTILITYATOMICCASTDECLARE / SFMUTILITYATOMICCASTIMPLEMENT macros for declaring and implementing the mutual type conversion function between the AtomRec struct and its corresopnding class or structure (atomic_cast operator)

Example

class Class {
  public:
    SFMTYPEDEFSTRUCT(AtomRec)
    struct AtomRec {
      SFMUTILITYATOMDECLARE(Class)

        ...

}

SFMUTILITYATOMICCASTDECLARE(Class, AtomRec)

SFMUTILITYATOMIMPLEMENT(Class, AtomRec)
SFMUTILITYATOMICCASTIMPLEMENT(Class, AtomRec)

Description

This macro takes a class name or a structure name as an argument and then generates the implementation of the implicit type conversion operator from the AtomRec struct into its corresponding class or structure as below.

inline Class::AtomicRec::operator Class&(void) 
{ 
    return *reinterpret_cast<Class*>(this); 
} 

inline Class::AtomicRec::operator Class const&(void) const
{ 
    return *reinterpret_cast<Class const*>(this);
}

	Caution
	The SFMUTILITYATOMIMPLEMENT macro is used for implementation together with the SFMUTILITYATOMDECLARE macro.

Example

class Class {
  public:
    SFMTYPEDEFSTRUCT(AtomRec)
    struct AtomRec {
      SFMUTILITYATOMDECLARE(Class)

        ...

}

SFMUTILITYATOMICCASTDECLARE(Class, AtomRec)

SFMUTILITYATOMIMPLEMENT(Class, AtomRec)
SFMUTILITYATOMICCASTIMPLEMENT(Class, AtomRec)

Description

This macro takes a class name or a structure name and its coresponding AtomRec struct as arguments and then generates the declaration of the mutual type conversion function between the AtomRec struct and its corresopnding class or structure (atomic_cast operator) as blow.

extern Class* atomic_cast(Class::AtomRec* param); 
extern Class const* atomic_cast(Class::AtomRec const* param);
extern Class::AtomRec* atomic_cast(Class* param); 
extern Class::AtomRec const* atomic_cast(Class const* param);

	Caution
	When you use the SFMUTILITYATOMICCASTDECLARE macro, you also have to use the SFMUTILITYATOMICCASTIMPLEMENT macro.

In general, this macro is used together with the SFMUTILITYATOMDECLARE / SFMUTILITYATOMIMPLEMENT macros which are for declaring and implementing the implicit type conversion operator from the AtomRec struct into its corresponding class or structure.

Example

class Class {
  public:
    SFMTYPEDEFSTRUCT(AtomRec)
    struct AtomRec {
      SFMUTILITYATOMDECLARE(Class)

        ...

}

SFMUTILITYATOMICCASTDECLARE(Class, AtomRec)

SFMUTILITYATOMIMPLEMENT(Class, AtomRec)
SFMUTILITYATOMICCASTIMPLEMENT(Class, AtomRec)

Description

This macro takes a class name or a structure name and its coresponding AtomRec struct as arguments and then generates the implementaion of the mutual type conversion function between the AtomRec struct and its corresopnding class or structure (atomic_cast operator) as blow.

inline Class::AtomicRec* atomic_cast(Class* param)
{ 
    return reinterpret_cast<Class::AtomicRec*>(param);
} 

inline Class::AtomicRec const* atomic_cast(Class const* param)
{ 
    return reinterpret_cast<Class::AtomicRec const*>(param);
}

inline Class* atomic_cast(Class::AtomicRec* param)
{ 
    return reinterpret_cast<Class*>(param);
} 

inline Class const* atomic_cast(Class::AtomicRec const* param)
{ 
    return reinterpret_cast<Class const*>(param);
}

	Caution
	The SFMUTILITYATOMICCASTIMPLEMENT macro is used for implementation together with the SFMUTILITYATOMICCASTDECLARE macro.

Example

class Class {
  public:
    SFMTYPEDEFSTRUCT(AtomRec)
    struct AtomRec {
      SFMUTILITYATOMDECLARE(Class)

        ...

}

SFMUTILITYATOMICCASTDECLARE(Class, AtomRec)

SFMUTILITYATOMIMPLEMENT(Class, AtomRec)
SFMUTILITYATOMICCASTIMPLEMENT(Class, AtomRec)

Description

You cannot create the instance of class which consists of static members only.

The SFMSEALCONSTRUCT macro takes the class name as an argument, and is expanded as follows:

private:
explicit Class(void);
Class(Class const&);
~Class(void);
const Class& operator=(Class const&);

Example

SFMTYPEDEFCLASS(A)
class A {
  SFMSEALCONSTRUCT(A)
  ...
}

Description

For a wrapper class, use the SFMSEALWRAPPER macro instead of SFMSEALCONSTRUCT.

Description

In the Responder class, use the SFMSEALRESPONDER macro instead of the SFMSEALCONSTRUCT macro.

Description

In the classes such as for buffer management, the problem on copying an instance can be avoided.

The SFMSEALCOPY macro takes the class name as an argument, and is expanded as follows:

private:
Class(Class const&);
Class& operator=(Class const&);

Description

The problem on assigning an instance can be avoided.

The SFMSEALASSIGN macro takes the class name as an argument, and is expanded as follows:

private:
Class& operator=(Class const&);

Description

When a responder class defined newly, you have to describe the inherihance relation from SFYResponder to newly defined class using SFMRESPONDERINSTANTIATEZERO, SFMRESPONDERINSTANTIATEONE, SFMRESPONDERINSTANTIATETWO, SFMRESPONDERINSTANTIATETHREE, SFMRESPONDERINSTANTIATEFOUR, SFMRESPONDERINSTANTIATEFIVE, SFMRESPONDERINSTANTIATESIX, SFMRESPONDERINSTANTIATESEVEN depending on the number of inheritance layers.

For instance, think of the MyWindow as below. MyWindow, SFZWindow, SFYContainer, and SFYWidget inherit from SFZWindow, SFYContainer, SFYWidget, and SFYWidget respectively. Since there is four layers from SFYResponder to MyWindow, use the SFMRESPONDERINSTANTIATEFOUR macro.

If the number of inheritance layers from SFYResponder is three, use the SFMRESPONDERINSTANTIATETHREE macro. If five layers, use the SFMRESPONDERINSTANTIATEFIVE macro. This macro is provided with up to the SFMRESPONDERINSTANTIATESEVEN macro which is used in inheriting from seven layers.

	Bug on RealView Compilation Tools for BREW 1.2
	This macro is necessary for avoiding a bug of RealView Compilation Tools for BREW 1.2 compiler. This macro is ignored in compilers other than RealView Compilation Tools for BREW 1.2.

Description

When defining a wrapper class newly, you have to describe the inherihance relation from the SFBBase class to newly defined class using SFMWRAPPERINSTANTIATEZERO, SFMWRAPPERINSTANTIATEONE, SFMWRAPPERINSTANTIATETWO, SFMWRAPPERINSTANTIATETHREE, SFMWRAPPERINSTANTIATEFOUR, SFMWRAPPERINSTANTIATEFIVE, SFMWRAPPERINSTANTIATESIX, SFMWRAPPERINSTANTIATESEVEN depending on the number of inheritance layers.

Since the IHash interface inherits from the IBase interface, when the wrapper class for the IBase interface is the SFBBase class and the wrapper class for the IHash interface is the SFBHash class, declare the SFMWRAPPERINSTANTIATEONE(SFBHash, SFBBase) macro.

In the SFBBase class, since this class is the highest in the inheritance relation, declare SFMWRAPPERINSTANTIATEZERO(SFBBase) using the SFMWRAPPERINSTANTIATEZERO macro.

There are three warpper classes called A, B, and C. B inherits from A and C inherits from B respectively. Then declare SFMWRAPPERINSTANTIATETWO(C, B, A) using the SFMWRAPPERINSTANTIATETWO macro.

In case of four wrapper classes of A, B, C, amd D, declare the SFMWRAPPERINSTANTIATETHREE(D, C, B, A) macro.

	Bug on RealView Compilation Tools for BREW 1.2
	This macro is necessary for avoiding a bug of RealView Compilation Tools for BREW 1.2 compiler. This macro is ignored in compilers other than RealView Compilation Tools for BREW 1.2.

Description

When a reference-counted class defined newly, you have to describe the inherihance relation from SFORefObject to newly defined class using SFMREFOBJECTINSTANTIATEZERO, SFMREFOBJECTINSTANTIATEONE, SFMREFOBJECTINSTANTIATETWO, SFMREFOBJECTINSTANTIATETHREE, SFMREFOBJECTINSTANTIATEFOUR, SFMREFOBJECTINSTANTIATEFIVE, SFMREFOBJECTINSTANTIATESIX, SFMREFOBJECTINSTANTIATESEVEN depending on the number of inheritance layers.

For instance, think of the MyTableCellReactor as below. MyTableCellReactor and SFOTableCellReactor inherit from SFOTableCellReactor and SFORefObject respectively. Since there is two layers from SFORefObject to MyTableCellReactor, use the SFMREFOBJECTINSTANTIATETWO macro.

If the number of inheritance layers from SFORefObject is three, use the SFMREFOBJECTINSTANTIATETHREE macro. If four layers, use the SFMREFOBJECTINSTANTIATEFOUR macro. This macro is provided with up to the SFMREFOBJECTINSTANTIATESEVEN macro which is used in inheriting from seven layers.

	Bug on RealView Compilation Tools for BREW 1.2
	This macro is necessary for avoiding a bug of RealView Compilation Tools for BREW 1.2 compiler. This macro is ignored in compilers other than RealView Compilation Tools for BREW 1.2.

Example

Generate the 4-character literal.

SFCType val = four_char_code('A', 'b', 'c', 'd');
ACharPtr p = reinterpret_cast<ACharPtr>(&val);