factory.h

网络游戏通用架构, 这是基于boost和libevent写的一个程序

#ifndef FACTORY_H
#define FACTORY_H

#include <assert.h>
#include <string>
#include <list>
#include <vector>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <boost/program_options.hpp>
#include <boost/thread/recursive_mutex.hpp>

using namespace std;
using namespace boost;
using namespace boost::program_options;

#include "common.h"
#include "class.h"
#include "dynamicfactory.h"

class EXPORT Factory
{
public:
    Factory();
    ~Factory();
public:
    void* newInstance( const string& __name );
    void* newInstance( const int __type );
    void addClass( ClassInterface* __class );
    void parse_types( string& __typetab_filename );
    void removeClass( const string& __name );
    bool loadFactory( const string& __filename, const string& __getFactory_func_name= "getFactory" );//return true if succeeded
    void unloadFactory( const string& __filename );
protected:
    recursive_mutex _mutex;
    options_description _opt_desc;
    vector<ClassInterface*> _classes;
    list<DynamicFactory*> _factories;
protected:
    class ClassNameFindOp
    {
    public:
    ClassNameFindOp( const string& __name ) : _name(__name) {}
    bool operator() ( const ClassInterface* __class )
    {
        assert( __class );
        return ( __class->getName()==_name );
    }
    const string& _name;
    };
    class ClassTypeFindOp
    {
    public:
    ClassTypeFindOp( const int __type ) : _type(__type) {}
    bool operator() ( const ClassInterface* __class )
    {
        assert( __class );
        return ( __class->getType()==_type );
    }
    const int _type;
    };
    class FactoryFindOp
    {
    public:
    FactoryFindOp( const string& __name ) : _name(__name) {}
    bool operator() ( const DynamicFactory* __factory )
    {
        assert( __factory );
        return ( __factory->getFilename()==_name );
    }
    const string& _name;
    };
};


#define REGISTER( FACTORY, CLASS ) \
    { \
        ClassInterface* classInterface= NULL; \
        try{ \
            classInterface= new Class<CLASS>(#CLASS); \
        }catch( exception& e ){ \
            classInterface= NULL; \
            cerr << "Register class failed: " << #CLASS << " as " << #CLASS << "\t(" << e.what() << ")" << endl; \
        }catch( ... ){ \
            classInterface= NULL; \
            cerr << "Register class failed: " << #CLASS << " as " << #CLASS << "\t(" << "Unknown exception" << ")" << endl; \
        } \
        if( classInterface ){ \
            FACTORY.addClass( classInterface ); \
        } \
    } \

#define REGISTER_AS( FACTORY, CLASS, NAME ) \
    { \
        ClassInterface* classInterface= NULL; \
        try{ \
            classInterface= new Class<CLASS>(NAME); \
        }catch( exception& e ){ \
            classInterface= NULL; \
            cerr << "Register class failed: " << #CLASS << " as " << NAME << "\t(" << e.what() << ")" << endl; \
        }catch( ... ){ \
            classInterface= NULL; \
            cerr << "Register class failed: " << #CLASS << " as " << NAME << "\t(" << "Unknown exception" << ")" << endl; \
        } \
        if( classInterface ){ \
            FACTORY.addClass( classInterface ); \
        } \
    } \

#endif