コード例 #1
0
ファイル: ServiceEvent.cpp プロジェクト: mr-kelly/llbc
LLBC_MessageBlock *LLBC_SvcEvUtil::BuildDataArrivalEv(LLBC_Packet *packet)
{
    typedef LLBC_SvcEv_DataArrival _Ev;

    _Ev *ev = LLBC_New(_Ev);
    ev->packet = packet;

    return __CreateEvBlock(ev);
}
コード例 #2
0
ファイル: ServiceEvent.cpp プロジェクト: mr-kelly/llbc
LLBC_MessageBlock *LLBC_SvcEvUtil::BuildFireEvEv(LLBC_Event *ev)
{
    typedef LLBC_SvcEv_FireEv _Ev;

    _Ev *e = LLBC_New(_Ev);
    e->ev = ev;

    return __CreateEvBlock(e);
}
コード例 #3
0
ファイル: ServiceEvent.cpp プロジェクト: mr-kelly/llbc
LLBC_MessageBlock *LLBC_SvcEvUtil::BuildSessionDestroyEv(int sessionId)
{
    typedef LLBC_SvcEv_SessionDestroy _Ev;

    _Ev *ev = LLBC_New(_Ev);
    ev->sessionId = sessionId;

    return __CreateEvBlock(ev);
}
コード例 #4
0
ファイル: ServiceEvent.cpp プロジェクト: mr-kelly/llbc
LLBC_MessageBlock *LLBC_SvcEvUtil::BuildUnsubscribeEvEv(int id, const LLBC_String &stub)
{
    typedef LLBC_SvcEv_UnsubscribeEv _Ev;

    _Ev *ev = LLBC_New(_Ev);
    ev->id = id;
    ev->stub.append(stub);

    return __CreateEvBlock(ev);
}
コード例 #5
0
ファイル: IocpPoller.cpp プロジェクト: lailongwei/llbc
void LLBC_IocpPoller::HandleEv_AsyncConn(LLBC_PollerEvent &ev)
{
    bool succeed = true;
    LLBC_String reason = "Success";
    do {
        LLBC_SocketHandle handle = LLBC_CreateTcpSocketEx();
        if (handle == LLBC_INVALID_SOCKET_HANDLE)
        {
            succeed = false;
            reason = LLBC_FormatLastError();
            break;
        }

        LLBC_Socket *socket = LLBC_New1(LLBC_Socket, handle);

        socket->SetNonBlocking();
        socket->SetPollerType(LLBC_PollerType::IocpPoller);
        if (socket->AttachToIocp(_iocp) != LLBC_OK)
        {
            LLBC_Delete(socket);

            succeed = false;
            reason = LLBC_FormatLastError();
            break;
        }

        LLBC_POverlapped ol = LLBC_New(LLBC_Overlapped);
        ol->opcode = LLBC_OverlappedOpcode::Connect;
        ol->sock = handle;
        if (socket->ConnectEx(ev.peerAddr, ol) != LLBC_OK &&
                LLBC_GetLastError() != LLBC_ERROR_PENDING)
        {
            LLBC_Delete(ol);
            LLBC_Delete(socket);

            succeed = false;
            reason = LLBC_FormatLastError();
            break;
        }

        socket->InsertOverlapped(ol);

        LLBC_AsyncConnInfo asyncInfo;
        asyncInfo.socket = socket;
        asyncInfo.peerAddr = ev.peerAddr;
        asyncInfo.sessionId = ev.sessionId;

        _connecting.insert(std::make_pair(handle, asyncInfo));
    } while (false);

    if (!succeed)
        _svc->Push(LLBC_SvcEvUtil::
                BuildAsyncConnResultEv(succeed, reason, ev.peerAddr));
}
コード例 #6
0
ファイル: ServiceEvent.cpp プロジェクト: mr-kelly/llbc
LLBC_MessageBlock *LLBC_SvcEvUtil::BuildSubscribeEvEv(int id,
                                                      const LLBC_String &stub,
                                                      LLBC_IDelegate1<LLBC_Event *> *deleg)
{
    typedef LLBC_SvcEv_SubscribeEv _Ev;

    _Ev *ev = LLBC_New(_Ev);
    ev->id = id;
    ev->stub.append(stub);
    ev->deleg = deleg;

    return __CreateEvBlock(ev);
}
コード例 #7
0
ファイル: ServiceEvent.cpp プロジェクト: mr-kelly/llbc
LLBC_MessageBlock *LLBC_SvcEvUtil::BuildAsyncConnResultEv(bool connected,
                                                          const LLBC_String &reason,
                                                          const LLBC_SockAddr_IN &peer)
{
    typedef LLBC_SvcEv_AsyncConn _Ev;

    _Ev *ev = LLBC_New(_Ev);
    ev->connected = connected;
    ev->reason.append(reason);
    ev->peer = peer;

    return __CreateEvBlock(ev);
}
コード例 #8
0
ファイル: PyService.cpp プロジェクト: mr-kelly/llbc
int pyllbc_Service::Send(int sessionId, int opcode, PyObject *data, int status, PyObject *parts)
{
    // Started check.
    if (UNLIKELY(!this->IsStarted()))
    {
        pyllbc_SetError("service not start");
        return LLBC_RTN_FAILED;
    }

    // Build parts, if exists.
    LLBC_PacketHeaderParts *cLayerParts = NULL;
    if (parts && _llbcSvcType != LLBC_IService::Raw)
    {
        if (!(cLayerParts = this->BuildCLayerParts(parts)))
            return LLBC_RTN_FAILED;
    }

    // Serialize python layer 'data' object to stream.
    LLBC_Stream stream;
    const int ret = this->SerializePyObj2Stream(data, stream);
    if (UNLIKELY(ret != LLBC_RTN_OK))
    {
        LLBC_XDelete(cLayerParts);
        return LLBC_RTN_FAILED;
    }

    // Build packet & send.
    LLBC_Packet *packet = LLBC_New(LLBC_Packet);
    packet->Write(stream.GetBuf(), stream.GetPos());

    packet->SetSessionId(sessionId);
    if (_llbcSvcType != LLBC_IService::Raw)
    {
        packet->SetOpcode(opcode);
        packet->SetStatus(status);

        if (cLayerParts)
        {
            cLayerParts->SetToPacket(*packet);
            LLBC_Delete(cLayerParts);
        }
    }

    if (UNLIKELY(_llbcSvc->Send(packet) == LLBC_RTN_FAILED))
    {
        pyllbc_TransferLLBCError(__FILE__, __LINE__);
        return LLBC_RTN_FAILED;
    }

    return LLBC_RTN_OK;
}
コード例 #9
0
ファイル: ServiceEvent.cpp プロジェクト: mr-kelly/llbc
LLBC_MessageBlock *LLBC_SvcEvUtil::BuildProtoReportEv(int sessionId,
                                                      int layer,
                                                      int level,
                                                      const LLBC_String &report)
{
    typedef LLBC_SvcEv_ProtoReport _Ev;

    _Ev *ev = LLBC_New(_Ev);
    ev->sessionId = sessionId;
    ev->layer = layer;
    ev->level = level;
    ev->report.append(report);

    return __CreateEvBlock(ev);
}
コード例 #10
0
int TestCase_Comm_Event::Run(int argc, char *argv[])
{
    std::cout <<"Core/Event component testcase..." <<std::endl;

    // We create a service to test.
    LLBC_IService *svc = LLBC_IService::Create(LLBC_IService::Normal);
    svc->RegisterFacade(LLBC_New(EventTestFacade));
    svc->Start();

    std::cout <<"Press any key to continue..." <<std::endl;
    getchar();

    delete svc;

    return LLBC_OK;
}
コード例 #11
0
ファイル: ServiceEvent.cpp プロジェクト: mr-kelly/llbc
LLBC_MessageBlock *LLBC_SvcEvUtil::BuildSessionCreateEv(const LLBC_SockAddr_IN &local,
                                                        const LLBC_SockAddr_IN &peer,
                                                        bool isListen,
                                                        int sessionId,
                                                        LLBC_SocketHandle handle)
{
    typedef LLBC_SvcEv_SessionCreate _Ev;

    _Ev *ev = LLBC_New(_Ev);
    ev->isListen = isListen;
    ev->sessionId = sessionId;
    ev->local = local;
    ev->peer = peer;
    ev->handle = handle;

    return __CreateEvBlock(ev);
}
コード例 #12
0
int TestCase_Comm_LazyTask::Run(int argc, char *argv[])
{
    LLBC_PrintLine("service/lazy task test:");

    LLBC_IService *svc = LLBC_IService::Create(LLBC_IService::Normal);

    LazyClass *taskObj = LLBC_New(LazyClass);
    svc->Post(taskObj, &LazyClass::BeforeRun);

    svc->Start();

    LLBC_PrintLine("Press any key to exit...");
    getchar();

    LLBC_Delete(svc);
    LLBC_Delete(taskObj);

    return LLBC_OK;
}
コード例 #13
0
ファイル: PackLemma_Dict.cpp プロジェクト: mr-kelly/llbc
int pyllbc_PackLemma_Dict::Process(Symbol ch, Symbol nextCh)
{
    // State logic.
    if (_state == Base::Done && _state == Base::Error)
    {
        pyllbc_SetError("dict-lemma state is done or error, could not continuing to parse format string");
        return LLBC_RTN_FAILED;
    }

    if (_state == Base::Begin)
    {
        if (ch != Base::DictBegin)
        {
            _state = Base::Error;
            pyllbc_SetError("dict-lemma expect dict begin character'{', got %c", ch);

            return LLBC_RTN_FAILED;
        }

        _state = Base::Accepting;
        _str.append(1, static_cast<char>(ch));

        return LLBC_RTN_OK;
    }

    // Key-Word separator & dict close character('}') logic.
    if (ch == Base::DictKWSep)
    {
        if (!_keyLemma)
        {
            _state = Base::Error;
            pyllbc_SetError("dict-lemma expect key lemma, got key-word separator");

            return LLBC_RTN_FAILED;
        }
        else if (_valueLemma)
        {
            _state = Base::Error;
            pyllbc_SetError("dict-lemma expect dict close character '}', got key-word separator");

            return LLBC_RTN_FAILED;
        }

        _gotKwSep = true;
        _str.append(1, static_cast<char>(ch));

        return LLBC_RTN_OK;
    }
    else if (ch == Base::DictEnd)
    {
        if (!_keyLemma || !_valueLemma)
        {
            _state = Base::Error;
            pyllbc_SetError("dict-lemma not done, but got dict close character '}'");

            return LLBC_RTN_FAILED;
        }

        _state = Base::Done;
        _str.append(1, static_cast<char>(ch));

        return LLBC_RTN_OK;
    }

    const SymbolGroup &raw = GroupedSymbol::Raw();
    if (raw.find(ch) == raw.end())
    {
        _state = Base::Error;
        pyllbc_SetError("dict-lemma could direct process non-raw type format character: %c", ch);

        return LLBC_RTN_FAILED;
    }

    Base *lemma = LLBC_New(pyllbc_PackLemma_Raw);
    if (lemma->Process(ch) != LLBC_RTN_OK)
    {
        delete lemma;
        _state = Base::Error;

        return LLBC_RTN_FAILED;
    }

    if (this->Process(lemma) != LLBC_RTN_OK)
    {
        delete lemma;
        return LLBC_RTN_FAILED;
    }

    return LLBC_RTN_OK;
}
コード例 #14
0
int TestCase_Comm_SendBytes::Run(int argc, char *argv[])
{
    LLBC_PrintLine("Servie send bytes test:");
    if (argc < 5)
    {
        LLBC_PrintLine("argument error, eg: ./a [client/server] [normal/raw] ip port");
        return LLBC_FAILED;
    }

    FetchArgs(argc, argv);
    LLBC_IService *svc = LLBC_IService::Create(_svcType);

    TestFacade *facade = LLBC_New(TestFacade);
    svc->RegisterFacade(facade);

    svc->Subscribe(OPCODE, facade, &TestFacade::OnRecv);

    int sid = 0;
    if (_asClient)
    {
        sid = svc->Connect(_runIp.c_str(), _runPort);
        if (sid == 0)
        {
            LLBC_FilePrintLine(stderr, "connect to %s:%d failed, err: %s",
                _runIp.c_str(), _runPort, LLBC_FormatLastError());
            LLBC_Delete(svc);

            return LLBC_FAILED;
        }

        LLBC_PrintLine("server connect to %s:%d success", _runIp.c_str(), _runPort);
    }
    else
    {
        sid = svc->Listen(_runIp.c_str(), _runPort);
        if (sid == 0)
        {
            LLBC_FilePrintLine(stderr, "failed to listen on %s:%d, err: %s",
                _runIp.c_str(), _runPort, LLBC_FormatLastError());
            LLBC_Delete(svc);

            return LLBC_FAILED;
        }

        LLBC_PrintLine("server listen on %s:%d", _runIp.c_str(), _runPort);
    }

    svc->Start();

    if (_asClient)
    {
        LLBC_Packet *pkt = LLBC_New(LLBC_Packet);
        pkt->SetHeader(sid, OPCODE, 0);
        pkt->Write("Hello, world");
        pkt->Write(0);

        svc->Send(pkt);
    }

    LLBC_PrintLine("Press any key to continue...");
    getchar();

    LLBC_Delete(svc);

    return LLBC_OK;
}
コード例 #15
0
ファイル: PyService.cpp プロジェクト: mr-kelly/llbc
#include "pyllbc/comm/PyService.h"

namespace
{
    typedef pyllbc_Service This;

    void ResetMainloopFlag(void *flagPtr)
    {
        bool *flag = reinterpret_cast<bool *>(flagPtr);
        *flag = false;
    }
}

int pyllbc_Service::_maxLLBCSvcId = 0;
PyObject *pyllbc_Service::_streamCls = NULL;
pyllbc_ErrorHooker *pyllbc_Service::_errHooker = LLBC_New(pyllbc_ErrorHooker);

pyllbc_Service::pyllbc_Service(LLBC_IService::Type type, PyObject *pySvc)
: _llbcSvc(NULL)
, _llbcSvcType(type)

, _pySvc(pySvc)

, _inMainloop()

, _cppFacade(NULL)
, _facades()

, _handlers()
, _preHandlers()
#if LLBC_CFG_COMM_ENABLE_UNIFY_PRESUBSCRIBE
コード例 #16
0
ファイル: PyService.cpp プロジェクト: mr-kelly/llbc
LLBC_PacketHeaderParts *pyllbc_Service::BuildCLayerParts(PyObject *pyLayerParts)
{
    // Python layer parts(dict type) convert rules describe:
    //   python type       c++ type
    // --------------------------
    //   int/long/bool -->   sint64
    //     float4/8    -->  float/double
    //   str/bytearray -->  LLBC_String

    if (!PyDict_Check(pyLayerParts))
    {
        pyllbc_SetError("parts instance not dict type");
        return NULL;
    }

    LLBC_PacketHeaderParts *cLayerParts = LLBC_New(LLBC_PacketHeaderParts);

    Py_ssize_t pos = 0;
    PyObject *key, *value;
    while (PyDict_Next(pyLayerParts, &pos, &key, &value)) // key & value are borrowed.
    {
        const int serialNo = static_cast<int>(PyInt_AsLong(key));
        if (UNLIKELY(serialNo == -1 && PyErr_Occurred()))
        {
            pyllbc_TransferPyError("When fetch header part serial no");
            LLBC_Delete(cLayerParts);

            return NULL;
        }

        // Value type check order:
        //   int->
        //     str->
        //       float->
        //         long->
        //           bool->
        //             bytearray->
        //               other objects
        if (PyInt_CheckExact(value))
        {
            const sint64 cValue = PyInt_AS_LONG(value);
            cLayerParts->SetPart<sint64>(serialNo, cValue);
        }
        else if (PyString_CheckExact(value))
        {
            char *strBeg;
            Py_ssize_t strLen;
            if (UNLIKELY(PyString_AsStringAndSize(value, &strBeg, &strLen) == -1))
            {
                pyllbc_TransferPyError("When fetch header part value");
                LLBC_Delete(cLayerParts);

                return NULL;
            }

            cLayerParts->SetPart(serialNo, strBeg, strLen);

        }
        else if (PyFloat_CheckExact(value))
        {
            const double cValue = PyFloat_AS_DOUBLE(value);
            cLayerParts->SetPart<double>(serialNo, cValue);
        }
        else if (PyLong_CheckExact(value))
        {
            const sint64 cValue = PyLong_AsLongLong(value);
            cLayerParts->SetPart<sint64>(serialNo, cValue);
        }
        else if (PyBool_Check(value))
        {
            const int pyBoolCheck = PyObject_IsTrue(value);
            if (UNLIKELY(pyBoolCheck == -1))
            {
                pyllbc_TransferPyError("when fetch header part value");
                LLBC_Delete(cLayerParts);

                return NULL;
            }

            cLayerParts->SetPart<uint8>(serialNo, pyBoolCheck);
        }
        else if (PyByteArray_CheckExact(value))
        {
            char *bytesBeg = PyByteArray_AS_STRING(value);
            Py_ssize_t bytesLen = PyByteArray_GET_SIZE(value);

            cLayerParts->SetPart(serialNo, bytesBeg, bytesLen);
        }
        else // Other types, we simple get the object string representations.
        {
            LLBC_String strRepr = pyllbc_ObjUtil::GetObjStr(value);
            if (UNLIKELY(strRepr.empty() && PyErr_Occurred()))
            {
                LLBC_Delete(cLayerParts);
                return NULL;
            }

            cLayerParts->SetPart(serialNo, strRepr.data(), strRepr.size());
        }
    }

    return cLayerParts;
}
コード例 #17
0
void TestCase_Comm_PacketHeaderParts::TestSetToPacket()
{
    LLBC_PrintLine("Test SetToPacket() method:");
    //! First, We must design packet header format.
    LLBC_PrintLine("  Fristly, we design packet header format.");
    LLBC_PacketHeaderDesc *headerDesc = LLBC_New(LLBC_PacketHeaderDesc);

    int serialNo = 0;
    headerDesc->AddPartDesc()
        .SetSerialNo(serialNo++).SetPartLen(sizeof(sint8)).Done();
    headerDesc->AddPartDesc()
        .SetSerialNo(serialNo++).SetPartLen(sizeof(uint8)).Done();
    headerDesc->AddPartDesc()
        .SetSerialNo(serialNo++).SetPartLen(sizeof(sint16)).Done();
    headerDesc->AddPartDesc()
        .SetSerialNo(serialNo++).SetPartLen(sizeof(uint16)).Done();
    headerDesc->AddPartDesc()
        .SetSerialNo(serialNo++).SetPartLen(sizeof(sint32))
        .SetIsLenPart(true).Done();
    headerDesc->AddPartDesc()
        .SetSerialNo(serialNo++).SetPartLen(sizeof(uint32))
        .SetIsOpcodePart(true).Done();
    headerDesc->AddPartDesc()
        .SetSerialNo(serialNo++).SetPartLen(sizeof(sint64)).Done();
    headerDesc->AddPartDesc()
        .SetSerialNo(serialNo++).SetPartLen(sizeof(uint64)).Done();
    headerDesc->AddPartDesc()
        .SetSerialNo(serialNo++).SetPartLen(sizeof(float)).Done();
    headerDesc->AddPartDesc()
        .SetSerialNo(serialNo++).SetPartLen(sizeof(double)).Done();
    headerDesc->AddPartDesc()
        .SetSerialNo(serialNo++).SetPartLen(13).Done(); // "Hello World!"\0
    headerDesc->AddPartDesc()
        .SetSerialNo(serialNo++).SetPartLen(19).Done(); // "Hello std::string!"\0
    headerDesc->AddPartDesc()
        .SetSerialNo(serialNo++).SetPartLen(19).Done(); // "Hello LLBC_String!"\0

    LLBC_PrintLine("  Design packet header done, header length: %lu", headerDesc->GetHeaderLen());

    // Set header format describe to llbc framework.
    LLBC_Print("  Set to llbc framework...");
    LLBC_IService::SetPacketHeaderDesc(headerDesc);
    LLBC_PrintLine("Done!");

    // Set header value to packet.
    LLBC_Print("Set the header parts to packet...");
    LLBC_Packet packet;
    _parts.SetToPacket(packet);
    LLBC_PrintLine("Done!");

    // Fetch from packet.
    LLBC_PrintLine("Fetch values from packet.");
    serialNo = 0;
    LLBC_PrintLine("  serial %d: %c", serialNo, packet.GetHeaderPartAsSInt8(serialNo)), serialNo++;
    LLBC_PrintLine("  serial %d: %d", serialNo, packet.GetHeaderPartAsUInt8(serialNo)), serialNo++;
    LLBC_PrintLine("  serial %d: %d", serialNo, packet.GetHeaderPartAsSInt16(serialNo)), serialNo++;
    LLBC_PrintLine("  serial %d: %u", serialNo, packet.GetHeaderPartAsUInt16(serialNo)), serialNo++;
    LLBC_PrintLine("  serial %d: %d", serialNo, packet.GetHeaderPartAsSInt32(serialNo)), serialNo++;
    LLBC_PrintLine("  serial %d: %u", serialNo, packet.GetHeaderPartAsUInt32(serialNo)), serialNo++;
    LLBC_PrintLine("  serial %d: %lld", serialNo, packet.GetHeaderPartAsSInt64(serialNo)), serialNo++;
    LLBC_PrintLine("  serial %d: %llu", serialNo, packet.GetHeaderPartAsUInt64(serialNo)), serialNo++;
    LLBC_PrintLine("  serial %d: %f", serialNo, packet.GetHeaderPartAsFloat(serialNo)), serialNo++;
    LLBC_PrintLine("  serial %d: %f", serialNo, packet.GetHeaderPartAsDouble(serialNo)), serialNo++;
    LLBC_PrintLine("  serial %d: %s", serialNo, packet.GetHeaderPartAsStr(serialNo).c_str()), serialNo++; // "Hello World!"
    LLBC_PrintLine("  serial %d: %s", serialNo, packet.GetHeaderPartAsStr(serialNo).c_str()), serialNo++; // "Hello std::string!"
    LLBC_PrintLine("  serial %d: %s", serialNo, packet.GetHeaderPartAsStr(serialNo).c_str()), serialNo++; // "Hello LLBC_String!"
    LLBC_PrintLine("  Fetch Done!");
}
コード例 #18
0
ファイル: TestCase_Comm_Svc.cpp プロジェクト: lailongwei/llbc
int TestCase_Comm_Svc::Run(int argc, char *argv[])
{
    LLBC_PrintLine("Server/Client test:");
    if (argc < 5)
    {
        LLBC_PrintLine("argument error, eg: ./a [client/server] [normal/raw] ip port");
        return -1;
    }

    // Parse arguments.
    const char *ip = argv[3];
    const int port = LLBC_Str2Int32(argv[4]);
    const bool asClient = LLBC_String(argv[1]) == "client" ? true : false;
    LLBC_IService::Type svcType = 
        LLBC_String(argv[2]) == "normal" ? LLBC_IService::Normal : LLBC_IService::Raw;

    LLBC_PrintLine("Will start %s type service, service type: %s",
        asClient ? "CLIENT" : "SERVER",
        svcType == LLBC_IService::Normal ? "Normal" : "Raw");

    // Create service
    LLBC_IService *svc = LLBC_IService::Create(svcType);
    TestFacade *facade = LLBC_New(TestFacade);
    svc->RegisterFacade(facade);
    svc->Subscribe(OPCODE, facade, &TestFacade::OnDataArrival);
    svc->SuppressCoderNotFoundWarning();
    svc->Start(2);

    // Connect to server / Create listen session to wait client connect.
    int sessionId;
    if (!asClient)
    {
        LLBC_PrintLine("Will listening in %s:%d", ip, port);
        if ((sessionId = svc->Listen(ip, port)) == 0)
        {
            LLBC_PrintLine("Create session failed, reason: %s", LLBC_FormatLastError());
            LLBC_Delete(svc);

            return -1;
        }
    }
    else
    {
        // Client service, we create some clients to test service.
        int clientCount;
        const int pollerType = LLBC_PollerType::Str2Type(LLBC_CFG_COMM_POLLER_MODEL);
        if (pollerType == LLBC_PollerType::SelectPoller)
            clientCount = 50;
        else
            clientCount = 1024;

        LLBC_PrintLine("Create %d clients to test", clientCount);

        for (int i = 0; i < clientCount; i++)
        {
            const int sessionId = svc->Connect(ip, port);

            const int dataSize = 4096;
            char *data = LLBC_Malloc(char, dataSize);
            ::memset(data, 1, dataSize);

            LLBC_Packet *packet = LLBC_New(LLBC_Packet);
            packet->SetHeader(sessionId, OPCODE, 0);
            packet->Write(data, dataSize);

            LLBC_Free(data);

            svc->Send(packet);

            // Test unhandled packet(unsubscribe opcode).
            LLBC_Packet *unhandledPacket = LLBC_New(LLBC_Packet);
            unhandledPacket->SetHeader(sessionId, OPCODE + 10000, 0);
            unhandledPacket->Write("Hello World", 12);

            svc->Send(unhandledPacket);
        }
    }

    LLBC_PrintLine("Press any key to continue...");
    getchar();

    return 0;
}
コード例 #19
0
ファイル: SamplerGroup.cpp プロジェクト: mr-kelly/llbc
__LLBC_NS_BEGIN

LLBC_SamplerGroup::LLBC_SamplerGroup()
: _samplers(LLBC_New(_SamplerMap))
{
}