ZRTPConfig.h

//
// ZRTPConfig.h
// ZDK
//
 
#ifndef ZDK_NET_ZRTPConfig_h
#define ZDK_NET_ZRTPConfig_h
 
#include "native_shared_ptr.h"
#include "PublicInterfaces.h"
#include "ZRTPHashAlgorithm.h"
#include "ZRTPCipherAlgorithm.h"
#include "ZRTPAuthTag.h"
#include "ZRTPKeyAgreement.h"
#include "ZRTPSASEncoding.h"
#include "ZHandle.h"
 
using namespace System::Collections::Generic;
 
namespace ZDK_NET
{
    ref class ZRTPConfig;
 
    public ref class ZRTPConfig : ZHandle
    {
    public:
        ZDK::IZRTPConfig* cppRef = nullptr;
 
        ZRTPConfig(ZDK::Shared::ZRTPConfig src);
        ~ZRTPConfig();
        !ZRTPConfig();
 
        property bool EnableZRTP
        {
            bool get();
            void set(bool value);
        }
 
        property List<ZDK_NET::ZRTPHashAlgorithm>^ Hash
        {
            List<ZDK_NET::ZRTPHashAlgorithm>^ get();
            void set(List<ZDK_NET::ZRTPHashAlgorithm>^ value);
        }
 
        property List<ZDK_NET::ZRTPCipherAlgorithm>^ Cipher
        {
            List<ZDK_NET::ZRTPCipherAlgorithm>^ get();
            void set(List<ZDK_NET::ZRTPCipherAlgorithm>^ value);
        }
 
        property List<ZDK_NET::ZRTPAuthTag>^ Auth
        {
            List<ZDK_NET::ZRTPAuthTag>^ get();
            void set(List<ZDK_NET::ZRTPAuthTag>^ value);
        }
 
        property List<ZDK_NET::ZRTPKeyAgreement>^ KeyAgreement
        {
            List<ZDK_NET::ZRTPKeyAgreement>^ get();
            void set(List<ZDK_NET::ZRTPKeyAgreement>^ value);
        }
 
        property List<ZDK_NET::ZRTPSASEncoding>^ SasEncoding
        {
            List<ZDK_NET::ZRTPSASEncoding>^ get();
            void set(List<ZDK_NET::ZRTPSASEncoding>^ value);
        }
 
        property int CacheExpiry
        {
            int get();
            void set(int value);
        }
 
        bool IsEqual(ZDK_NET::ZRTPConfig^ comp);
 
        virtual long long Handle() override;
 
        virtual void Initialize() override;
 
        virtual void ReleaseReference() override;
 
    };
}
 
#endif