Nebula2探秘03-Object System研究

Nebula2探秘03-Object System研究happykevins文 首先要创建一个Nebula2符合ObjectSystem规范的类，下面代码创建了一个最简单的Nebula2类： /****************************************************************************/
/*    Nebula2 - Tutorial 03                                                    */
/*  ObjectSystem探秘                                                        */
/*    实现了一个最简单的Nebula2对象                                            */
/*  author: happykevins                                                        */
/****************************************************************************/
#pragma once

#include "kernel/nkernelserver.h"
#include "kernel/nroot.h"

/// Nebula对象的父类名（用于建立RTTI关联）
extern const char* SuperClassName;
/// Nebula对象的类名
extern const char* ThisClassName;
/// Nebula对象的初始化操作
extern bool  init_nebulaobj(nClass* clazz, nKernelServer* kernelServer);
/// Nebula对象的创建操作
extern void* new_nebulaobj();

///----------------------------------------------------------------------------
/// +NebulaObj
/// @note:
///    1.    Nebula2对象必须继承自Root类，因为整个NOH管理系统都是基于nroot的
///    2.    调用KernelServer的AddModule添加Nebula对象；需要为AddModule提供以下两个函数指针:
///        a.    bool (n_init_obj*)(nClass, nKernelServer)
///            提供向KernelServer注册该对象的操作
///        b.    void* (n_new_obj*)():
///            提供创建该对象实例的操作
///    3.    需要说明一点：Nebula对象是在调用AddModule时添加到类型列表的，而AddClass方法只是
///        建立了Class的层次关系，为Nebula的RTTI系统（将在后面的章节说明）提供支持。
///        而n_init_obj函数的主要工作就是建立RTTI的系统关联。
/// 4.    为了编码简单，Nebula2提供了nNebulaUsePackage,nNebulaClass,nNebulaScriptClass等宏
///        来替代手工添加Nebula类型的工作
class NebulaObj : public nRoot
{
public:
    // constructor
    NebulaObj()
    {
        nKernelServer::Instance()->Print("[NebulaObj]Construct! ");
    }
    // destructor
    ~NebulaObj()
    {
        nKernelServer::Instance()->Print("[NebulaObj]Destruct! ");
    }
    // do something
    void DoSomething(const char* msg)
    {
        nKernelServer::Instance()->Print("[NebulaObj]%s ", msg);
    }
};
/// +NebulaObj
///----------------------------------------------------------------------------
/****************************************************************************/
/*    Nebula2 - Tutorial 03                                                    */
/*  ObjectSystem探秘                                                        */
/*    实现了一个最简单的Nebula2对象                                            */
/*  author: happykevins                                                        */
/****************************************************************************/
#include "NebulaObj.h"

const char* SuperClassName = "nroot";
const char* ThisClassName = "tutorialobj";

/// Nebula对象的初始化操作
bool init_nebulaobj(nClass* clazz, nKernelServer* kernelServer)
{
    // 设置类名
    clazz->SetProperName(ThisClassName);
    // 设置类大小
    clazz->SetInstanceSize(sizeof(NebulaObj));
    // 让KernelServer来建立RTTI关联
    kernelServer->AddClass(SuperClassName, clazz);
    return true;
}

/// Nebula对象的创建操作
void* new_nebulaobj()
{
    return n_new(NebulaObj);
}下面是将Nebula2Obj添加到KernelServer，并在NOH中创建该对象的代码：
 
/****************************************************************************/
/*    Nebula2 - Tutorial 03                                                    */
/*  ObjectSystem探秘                                                        */
/*  author: happykevins                                                        */
/****************************************************************************/

///----------------------------------------------------------------------------
/// +链接库
#pragma comment(lib, "wsock32.lib")
#pragma comment(lib, "d_nkernel.lib")
/// -链接库
///----------------------------------------------------------------------------

///----------------------------------------------------------------------------
/// +必要头文件
#include "kernel/nkernelserver.h"
#include "util/nstack.h"
#include "util/nhashlist.h"
/// -必要头文件
///----------------------------------------------------------------------------

///----------------------------------------------------------------------------
/// +Tutorial的头文件
#include "NebulaObj.h"
/// -Tutorial的头文件
///----------------------------------------------------------------------------

// Kernel Server
nKernelServer* ks = NULL;

///----------------------------------------------------------------------------
/// +打印当前NOH树
void PrintNOH(nRoot* pRoot)
{
    // 内核加锁
    ks->Lock();

    // 层次栈
    // 在开始时将根节点入栈
    nStack deepStack;
    deepStack.Push(pRoot);
    
    // 遍历树
    do 
    {
        // 获得当前栈顶元素
        nRoot* obj = deepStack.Pop();

        // 打印该元素NOH名
        if ( obj->GetParent() )
        {
            ks->Print("%s ", obj->GetFullName().Get());
        }
        else
        {
            ks->Print("%s ", obj->GetName());
        }
        
        // 兄弟节点入栈
        if ( obj->IsLinked() && obj->GetSucc() )
        {
            deepStack.Push(obj->GetSucc());
        }

        // 第一个子节点入栈
        if ( obj->GetHead() )
        {
            deepStack.Push(obj->GetHead());
        }

    } while(!deepStack.IsEmpty());

    // 内核解锁
    ks->Unlock();
}
/// -打印当前NOH树
///----------------------------------------------------------------------------

///----------------------------------------------------------------------------
///    +打印当前Class列表
void PrintClasses()
{
    // 内核加锁
    ks->Lock();
    
    // 获得Class列表
    const nHashList* classList = ks->GetClassList();
    nHashNode* node = (nClass*)classList->GetHead();
    
    // 遍历输出Class列表
    do
    {
        nClass* cls = (nClass*)node;
        ks->Print("%s ", cls->GetName());
        node = node->GetSucc();
    } while ( node );

    // 内核解锁
    ks->Unlock();
}
///    -打印当前Class列表
///----------------------------------------------------------------------------

///----------------------------------------------------------------------------
///    +在Kernel中创建一个类
void CreateClass()
{
    ks->AddModule(ThisClassName, init_nebulaobj, new_nebulaobj);
}
///    -在Kernel中创建一个类
///----------------------------------------------------------------------------

///----------------------------------------------------------------------------
///    +创建类的实例
void CreateInstance()
{
    /// 我们要创建对象的指针
    NebulaObj* obj = NULL;

    /// 创建实例但不添加到NOH树中
    obj = (NebulaObj*)ks->New(ThisClassName);
    obj->DoSomething("Create Instance not in NOH!");
    /// 销毁对象
    obj->Release();
    obj = NULL;

    /// 创建实例并添加到NOH中
    /// 在NOH树中的对象将在KernelServer关闭时自动被销毁
    obj = (NebulaObj*)ks->New(ThisClassName, "/Tutorial/TutorialObj");
    obj->DoSomething("Create Instance in NOH!");

    /// 从NOH中查询对象
    obj = (NebulaObj*)ks->Lookup("/Tutorial/TutorialObj");
    obj->DoSomething("Lookup me in NOH!");
}
///    -创建类的实例
///----------------------------------------------------------------------------

///----------------------------------------------------------------------------
/// +Application
int main(int argc, const char** argv)
{
    /// 创建KernelServer
    ks = n_new(nKernelServer);

    /// 打印Class列表
    ks->Print("*****Pure Class List***** ");
    PrintClasses();

    /// 打印NOH: "/"是NOH根的名称
    ks->Print("*****Pure NOH Tree***** ");
    PrintNOH(ks->Lookup("/"));

    /// 在Kernel中创建一个类
    CreateClass();

    /// 打印Class列表
    ks->Print("*****Class List After Create Class: %s***** ", ThisClassName);
    PrintClasses();

    /// 创建类的实例
    ks->Print("*****Create Instance Test***** ");
    CreateInstance();

    /// 打印NOH: "/"是NOH根的名称
    ks->Print("*****NOH Tree After Create Instance***** ");
    PrintNOH(ks->Lookup("/"));

    /// 销毁KernelServer
    ks->Print("*****Closing KernelServer Here!***** ");
    n_delete(ks);

    getchar();
    return 0;
}
/// -Application
///----------------------------------------------------------------------------