rvmegacoobjects.h

h.248协议源码

/******************************************************************************
Filename:    rvmegacoobjects.h
Description: megaco objects
*******************************************************************************
                Copyright (c) 2000 RADVision Inc.
*******************************************************************************
NOTICE:
This document contains information that is proprietary to RADVision Inc.
No part of this publication may be reproduced in any form whatsoever without
written prior approval by RADVision Inc.

RADVision Inc. reserves the right to revise this publication and make changes
without obligation to notify any person of such revisions or changes.
******************************************************************************/

#ifndef RV_MEGACOOBJECTS_H
#define RV_MEGACOOBJECTS_H

#include "rvtypes.h"
#include "rvstring.h"
#include "rvvector.h"
#include "rvptrvector.h"
#include "rvlist.h"
#include "rvmap.h"
#include "rvsdp.h"
#include "rvutil.h"
#include "rvinet.h"

#if defined(__cplusplus)
extern "C" {
#endif


/*$
{type:
	{name: RvTimeStamp}
	{include: rvmegacoobjects.h}
	{description: {p:Time stamp.}}
	{methods:
		{method: RvTimeStamp *rvTimeStampConstruct(RvTimeStamp *x, unsigned int year, unsigned int month,
			unsigned int day, unsigned int hour, unsigned int minute, unsigned int hundredthsOfSeconds);}
		{method: RvTimeStamp *rvTimeStampConstructCurrentTime(RvTimeStamp *x); }
		{method: RvTimeStamp *rvTimeStampConstructBlank(RvTimeStamp *x); }
		{method: RvTimeStamp *rvTimeStampConstructCopy(RvTimeStamp *d, const RvTimeStamp *s);}
		{method: void rvTimeStampDestruct(RvTimeStamp *x);}
		{method: RvTimeStamp *rvTimeStampCopy(RvTimeStamp *d, const RvTimeStamp *s);}
		{method: RvBool rvTimeStampEqual(const RvTimeStamp *a, const RvTimeStamp *b);}
		{method: unsigned int rvTimeStampGetYear(const RvTimeStamp *x);}
		{method: unsigned int rvTimeStampGetMonth(const RvTimeStamp *x);}
		{method: unsigned int rvTimeStampGetDay(const RvTimeStamp *x);}
		{method: unsigned int rvTimeStampGetHour(const RvTimeStamp *x);}
		{method: unsigned int rvTimeStampGetMinute(const RvTimeStamp *x);}
		{method: double rvTimeStampGetSeconds(const RvTimeStamp *x);}
		{method: unsigned int rvTimeStampGetHsecs(const RvTimeStamp *x);}
		{method: RvBool rvTimeStampIsSet(const RvTimeStamp *x);}
	}
}
$*/
typedef struct
{
	unsigned int year, month, day, hour, minute, hsec;
} RvTimeStamp;

RvTimeStamp *rvTimeStampConstruct(RvTimeStamp *x, unsigned int year, unsigned int month, unsigned int day,
		unsigned int hour, unsigned int minute, unsigned int hundredthsOfSeconds);
RvTimeStamp *rvTimeStampConstructCurrentTime(RvTimeStamp *x); 
RvTimeStamp *rvTimeStampConstructBlank(RvTimeStamp *x); 

/*$
{function:
	{name: rvTimeStampConstructCopy}
	{class: RvTimeStamp}
	{include: rvmegacoobjects.h}
	{description:
		{p: Constructs a copy of a time stamp object.}
	}
	{proto: RvTimeStamp *rvTimeStampConstructCopy(RvTimeStamp *d, const RvTimeStamp *s, RvAlloc *alloc);}
	{params:
		{param: {n:d} {d:The destination time stamp object.}}
		{param: {n:s} {d:The time stamp object to copy.}}
		{param: {n:alloc} {d:The allocator to use.}}
	}
	{returns: A pointer to the constructed object, or NULL if construction failed.}
}
$*/
#define rvTimeStampConstructCopy rvDefaultConstructCopy

/*$
{function:
	{name: rvTimeStampDestruct}
	{class: RvTimeStamp}
	{include: rvmegacoobjects.h}
	{description:
		{p: Destroys a time stamp object.}
	}
	{proto: void rvTimeStampDestruct(RvTimeStamp *x);}
	{params:
		{param: {n:x} {d:The time stamp object.}}
	}
}
$*/
#define rvTimeStampDestruct rvDefaultDestruct

/*$
{function:
	{name: rvTimeStampCopy}
	{class: RvTimeStamp}
	{include: rvmegacoobjects.h}
	{description:
		{p: Copies the value of one time stamp object to another.}
	}
	{proto: RvTimeStamp *rvTimeStampCopy(RvTimeStamp *d, const RvTimeStamp *s);}
	{params:
		{param: {n:d} {d:The destination time stamp object.}}
		{param: {n:s} {d:The time stamp object to copy.}}
	}
	{returns: A pointer to the destination object, or NULL if the copy failed.}
}
$*/
#define rvTimeStampCopy rvDefaultCopy

RvBool rvTimeStampEqual(const RvTimeStamp *a, const RvTimeStamp *b);
unsigned int rvTimeStampGetYear(const RvTimeStamp *x);
unsigned int rvTimeStampGetMonth(const RvTimeStamp *x);
unsigned int rvTimeStampGetDay(const RvTimeStamp *x);
unsigned int rvTimeStampGetHour(const RvTimeStamp *x);
unsigned int rvTimeStampGetMinute(const RvTimeStamp *x);
double rvTimeStampGetSeconds(const RvTimeStamp *x);
unsigned int rvTimeStampGetHsecs(const RvTimeStamp *x);
RvBool rvTimeStampIsSet(const RvTimeStamp *x);


/*$
{type:
	{name: RvParseError}
	{include: rvmegacoobjects.h}
	{description: {p: Contains diagnostic information for parse failures.}}
	{methods:
		{method: RvParseError *rvParseErrorConstruct(RvParseError *x);}
		{method: RvParseError *rvParseErrorConstructA(RvParseError *x, RvAlloc *alloc);}
		{method: RvParseError *rvParseErrorConstructCopy(RvParseError *d, const RvParseError *s, RvAlloc *alloc);}
		{method: void rvParseErrorDestruct(RvParseError *x);}
		{method: RvParseError *rvParseErrorCopy(RvParseError *d, const RvParseError *s);}
		{method: void rvParseErrorSetMessage(RvParseError *x, const char *error);}
		{method: void rvParseErrorSetLine(RvParseError *x, int line);}
		{method: void rvParseErrorSetColumn(RvParseError *x, int column);}
		{method: const char *rvParseErrorGetMessage(const RvParseError *x);}
		{method: int rvParseErrorGetLine(const RvParseError *x);}
		{method: int rvParseErrorGetColumn(const RvParseError *x);}
	}
}
$*/

typedef struct
{
	RvString message;
	int line, column;
} RvParseError;

RvParseError *rvParseErrorConstruct(RvParseError *x);
RvParseError *rvParseErrorConstructA(RvParseError *x, RvAlloc *alloc);
RvParseError *rvParseErrorConstructCopy(RvParseError *d, const RvParseError *s, RvAlloc *alloc);
void rvParseErrorDestruct(RvParseError *x);
RvParseError *rvParseErrorCopy(RvParseError *d, const RvParseError *s);
void rvParseErrorSetMessage(RvParseError *x, const char *error);
void rvParseErrorSetLine(RvParseError *x, int line);
void rvParseErrorSetColumn(RvParseError *x, int column);
const char *rvParseErrorGetMessage(const RvParseError *x);
int rvParseErrorGetLine(const RvParseError *x);
int rvParseErrorGetColumn(const RvParseError *x);


/*$
{type:
	{name: RvMegacoEntityAddressType}
	{include: rvmegacoobjects.h}
	{description: 
		{p: Type of address contained in an RvMegacoEntityAddress.}
		{p: RV_MEGACOENTITYADDRESSTYPE_IP - IP address}
		{p: RV_MEGACOENTITYADDRESSTYPE_DNS - Domain name}
		{p: RV_MEGACOENTITYADDRESSTYPE_DEVICE - Device name}
		{p: RV_MEGACOENTITYADDRESSTYPE_MTP - MTP address}
	}
}
$*/
typedef enum
{
	RV_MEGACOENTITYADDRESSTYPE_IP,
	RV_MEGACOENTITYADDRESSTYPE_DNS,
	RV_MEGACOENTITYADDRESSTYPE_DEVICE,
	RV_MEGACOENTITYADDRESSTYPE_MTP
} RvMegacoEntityAddressType;


/*$
{type:
	{name: RvMegacoEntityAddress}
	{include: rvmegacoobjects.h}
	{description: {p: Stores network addresses of various formats.}}
	{methods:
		{method: RvMegacoEntityAddress *rvMegacoEntityAddressConstruct(RvMegacoEntityAddress *x, const char *dnsOrIp, RvInetPort port);}
		{method: RvMegacoEntityAddress *rvMegacoEntityAddressConstructA(RvMegacoEntityAddress *x, const char *dnsOrIp, RvInetPort port, RvAlloc *alloc);}
		{method: RvMegacoEntityAddress *rvMegacoEntityAddressConstructDevice(RvMegacoEntityAddress *x, const char *deviceName);}
		{method: RvMegacoEntityAddress *rvMegacoEntityAddressConstructDeviceA(RvMegacoEntityAddress *x, const char *deviceName, RvAlloc *alloc);}
		{method: RvMegacoEntityAddress *rvMegacoEntityAddressConstructMtp(RvMegacoEntityAddress *x, const char *mtpAddress);}
		{method: RvMegacoEntityAddress *rvMegacoEntityAddressConstructMtpA(RvMegacoEntityAddress *x, const char *mtpAddress, RvAlloc *alloc);}
		{method: RvMegacoEntityAddress *rvMegacoEntityAddressConstructCopy(RvMegacoEntityAddress *d, const RvMegacoEntityAddress *s, RvAlloc *alloc);}
		{method: void rvMegacoEntityAddressDestruct(RvMegacoEntityAddress *x);}
		{method: RvMegacoEntityAddress *rvMegacoEntityAddressCopy(RvMegacoEntityAddress *d, const RvMegacoEntityAddress *s);}
		{method: RvBool rvMegacoEntityAddressEqual(const RvMegacoEntityAddress *a, const RvMegacoEntityAddress *b);}
		{method: RvMegacoEntityAddressType rvMegacoEntityAddressGetType(const RvMegacoEntityAddress *x);}
		{method: const char *rvMegacoEntityAddressGetAddress(const RvMegacoEntityAddress *x);}
		{method: RvInetPort rvMegacoEntityAddressGetPort(const RvMegacoEntityAddress *x);}
		{method: RvBool rvMegacoEntityAddressIsSet(const RvMegacoEntityAddress *x);}
	}
}
$*/

typedef struct
{
	RvString address;
	RvInetPort port;
	RvMegacoEntityAddressType type;
	RvString deviceIp;
} RvMegacoEntityAddress;

RvMegacoEntityAddress *rvMegacoEntityAddressConstruct(RvMegacoEntityAddress *x, const char *dnsOrIp, RvInetPort port);
RvMegacoEntityAddress *rvMegacoEntityAddressConstructA(RvMegacoEntityAddress *x, const char *dnsOrIp, RvInetPort port, RvAlloc *alloc);
RvMegacoEntityAddress *rvMegacoEntityAddressConstructDevice(RvMegacoEntityAddress *x, const char *deviceName);
RvMegacoEntityAddress *rvMegacoEntityAddressConstructDeviceA(RvMegacoEntityAddress *x, const char *deviceName, RvAlloc *alloc);
RvMegacoEntityAddress *rvMegacoEntityAddressConstructMtp(RvMegacoEntityAddress *x, const char *mtpAddress);
RvMegacoEntityAddress *rvMegacoEntityAddressConstructMtpA(RvMegacoEntityAddress *x, const char *mtpAddress, RvAlloc *alloc);
RvMegacoEntityAddress *rvMegacoEntityAddressConstructAny(RvMegacoEntityAddress *x, const char *mid);
RvMegacoEntityAddress *rvMegacoEntityAddressConstructAnyA(RvMegacoEntityAddress *x, const char *mid, RvAlloc *alloc);
RvMegacoEntityAddress *rvMegacoEntityAddressConstructCopy(RvMegacoEntityAddress *d, const RvMegacoEntityAddress *s, RvAlloc *alloc);
void rvMegacoEntityAddressDestruct(RvMegacoEntityAddress *x);
RvMegacoEntityAddress *rvMegacoEntityAddressCopy(RvMegacoEntityAddress *d, const RvMegacoEntityAddress *s);
RvBool rvMegacoEntityAddressEqual(const RvMegacoEntityAddress *a, const RvMegacoEntityAddress *b);
RvMegacoEntityAddressType rvMegacoEntityAddressGetType(const RvMegacoEntityAddress *x);
const char *rvMegacoEntityAddressGetAddress(const RvMegacoEntityAddress *x);
RvInetPort rvMegacoEntityAddressGetPort(const RvMegacoEntityAddress *x);
const char *rvMegacoEntityAddressGetDeviceIp(const RvMegacoEntityAddress *x);
RvBool rvMegacoEntityAddressIsSet(const RvMegacoEntityAddress *x);


/*$
{type:
	{name: RvMegacoTerminationId}
	{include: rvmegacoobjects.h}
	{description: 
	{p: Termination identifier.}
	}
	{methods:
		{method: RvMegacoTerminationId *rvMegacoTerminationIdConstruct(RvMegacoTerminationId *x, const char *name);}
		{method: RvMegacoTerminationId *rvMegacoTerminationIdConstructA(RvMegacoTerminationId *x, const char *name, RvAlloc *alloc);}
		{method: RvMegacoTerminationId *rvMegacoTerminationIdConstructRoot(RvMegacoTerminationId *x);}
		{method: RvMegacoTerminationId *rvMegacoTerminationIdConstructRootA(RvMegacoTerminationId *x, RvAlloc *alloc);}
		{method: RvMegacoTerminationId *rvMegacoTerminationIdConstructCopy(RvMegacoTerminationId *d, const RvMegacoTerminationId *s, RvAlloc *alloc);}
		{method: void rvMegacoTerminationIdDestruct(RvMegacoTerminationId *x);}
		{method: RvMegacoTerminationId *rvMegacoTerminationIdCopy(RvMegacoTerminationId *d, const RvMegacoTerminationId *s);}
		{method: RvBool rvMegacoTerminationIdEqual(const RvMegacoTerminationId *a, const RvMegacoTerminationId *b);}
		{method: const char *rvMegacoTerminationIdGetId(const RvMegacoTerminationId *x);}
		{method: RvBool rvMegacoTerminationIdIsNormal(const RvMegacoTerminationId *x);}
		{method: RvBool rvMegacoTerminationIdIsRoot(const RvMegacoTerminationId *x);}
		{method: RvBool rvMegacoTerminationIdIsWild(const RvMegacoTerminationId *x);}
		{method: RvBool rvMegacoTerminationIdIsChoose(const RvMegacoTerminationId *x);}
	}
}
$*/

typedef struct
{
	RvString name;
} RvMegacoTerminationId;

RvMegacoTerminationId *rvMegacoTerminationIdConstruct(RvMegacoTerminationId *x, const char *name);
RvMegacoTerminationId *rvMegacoTerminationIdConstructA(RvMegacoTerminationId *x, const char *name, RvAlloc *alloc);
RvMegacoTerminationId *rvMegacoTerminationIdConstructRoot(RvMegacoTerminationId *x);
RvMegacoTerminationId *rvMegacoTerminationIdConstructRootA(RvMegacoTerminationId *x, RvAlloc *alloc);
RvMegacoTerminationId *rvMegacoTerminationIdConstructCopy(RvMegacoTerminationId *d, const RvMegacoTerminationId *s, RvAlloc *alloc);
void rvMegacoTerminationIdDestruct(RvMegacoTerminationId *x);