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 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

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 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&);

Example

Generate the 4-characters literal.

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