System.h

Go to the documentation of this file.

// Product  OpenNet


#pragma once

// Includes

// ===== Includes ===========================================================
#include <OpenNet/OpenNet.h>
#include <OpenNet/Status.h>
#include <OpenNetK/Adapter_Types.h>

namespace OpenNet
{

    class Adapter  ;
    class Kernel   ;
    class Processor;

    // Class

    class System
    {

    public:

        typedef struct
        {
            unsigned int mPacketSize_byte;

            unsigned char mReserved0[60];
        }
        Config;

        typedef struct
        {
            unsigned int mSystemId;

            unsigned char mReserved0[60];
        }
        Info;

        static OPEN_NET_PUBLIC const unsigned int START_FLAG_LOOPBACK;

        static OPEN_NET_PUBLIC System * Create();

        static OPEN_NET_PUBLIC Status Display(const Config & aConfig, FILE * aOut);

        static OPEN_NET_PUBLIC Status Display(const Info & aInfo, FILE * aOut);

        virtual Status GetConfig(Config * aOut) const = 0;

        virtual Status GetInfo(Info * aOut) const = 0;

        virtual Status SetConfig(const Config & aConfig) = 0;

        virtual void Delete();

        virtual Status Adapter_Connect(Adapter * aAdapter) = 0;

        virtual unsigned int Adapter_GetCount() const = 0;

        virtual Adapter * Adapter_Get( unsigned int aIndex ) = 0;

        virtual Adapter * Adapter_Get(OpenNetK::Adapter_Type aType, unsigned int aIndex) = 0;

        virtual Adapter * Adapter_Get(const unsigned char * aAddress, const unsigned char * aMask, const unsigned char * aMaskDiff) = 0;

        virtual Status Display(FILE * aOut) = 0;

        virtual OpenNet::Kernel * Kernel_Get(unsigned int aIndex) = 0;

        virtual unsigned int Kernel_GetCount() const = 0;

        virtual unsigned int Processor_GetCount() const = 0;

        virtual Processor * Processor_Get( unsigned int aIndex ) = 0;

        virtual Status Start(unsigned int aFlags) = 0;

        virtual Status Stop() = 0;

    protected:

        System();

        virtual ~System();

    private:

        System(const System &);

        const System & operator = (const System &);

    };

}