rvdatabuffer.c

h.248协议源码

		{param: {n:dataPtr} {d:A pointer the the variable to hold the data read from the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferWriteBackUint8 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method pushes an RvInt8 onto the back of the data buffer.}
	}
	{proto: void rvDataBufferWriteBackInt8(RvDataBuffer* thisPtr, RvInt8 data);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:data}    {d:The value to write into the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferReadBackUint16 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method reads and pops an RvUint16 from the back of the data buffer.}
	}
	{proto: void rvDataBufferReadBackUint16(RvDataBuffer* thisPtr, RvUint16* dataPtr);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:dataPtr} {d:A pointer the the variable to hold the data read from the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferWriteBackUint16 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method pushes an RvUint16 onto the back of the data buffer.}
	}
	{proto: void rvDataBufferWriteBackUint16(RvDataBuffer* thisPtr, RvUint16 data);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:data}    {d:The value to write into the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferReadBackInt16 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method reads and pops an RvInt16 from the back of the data buffer.}
	}
	{proto: void rvDataBufferReadBackInt16(RvDataBuffer* thisPtr, RvInt16* dataPtr);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:dataPtr} {d:A pointer the the variable to hold the data read from the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferWriteBackUint16 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method pushes an RvInt16 onto the back of the data buffer.}
	}
	{proto: void rvDataBufferWriteBackInt16(RvDataBuffer* thisPtr, RvInt16 data);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:data}    {d:The value to write into the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferReadBackUint32 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method reads and pops an RvUint32 from the back of the data buffer.}
	}
	{proto: void rvDataBufferReadBackUint32(RvDataBuffer* thisPtr, RvUint32* dataPtr);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:dataPtr} {d:A pointer the the variable to hold the data read from the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferWriteBackUint32 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method pushes an RvUint32 onto the back of the data buffer.}
	}
	{proto: void rvDataBufferWriteBackUint32(RvDataBuffer* thisPtr, RvUint32 data);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:data}    {d:The value to write into the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferReadBackInt32 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method reads and pops an RvInt32 from the back of the data buffer.}
	}
	{proto: void rvDataBufferReadBackInt32(RvDataBuffer* thisPtr, RvInt32* dataPtr);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:dataPtr} {d:A pointer the the variable to hold the data read from the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferWriteBackInt32 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method pushes an RvInt32 onto the back of the data buffer.}
	}
	{proto: void rvDataBufferWriteBackInt32(RvDataBuffer* thisPtr, RvInt32 data);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:data}    {d:The value to write into the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferReadAtUint8 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method reads a RvUint8 from the data buffer from a specified
            byte offset. This method does not affect the buffer's front or back 
            data pointers.}
	}
	{proto: void rvDataBufferReadAtUint8(RvDataBuffer* thisPtr, RvUint32 index, RvUint8* dataPtr);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:index}   {d:The byte offset to read the value from.}}
		{param: {n:dataPtr} {d:A pointer the the variable to hold the data read from the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferWriteAtUint8 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method writes a RvUint8 into the data buffer at a specified
            byte offset. This method does not affect the buffer's front or back 
            data pointers.}
	}
	{proto: void rvDataBufferWriteAtUint8(RvDataBuffer* thisPtr, RvUint32 index, RvUint8 data);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:index}   {d:The byte offset to write the value to.}}
		{param: {n:data}    {d:The value to write into the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferReadAtInt8 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method reads a RvInt8 from the data buffer from a specified
            byte offset. This method does not affect the buffer's front or back 
            data pointers.}
	}
	{proto: void rvDataBufferReadAtInt8(RvDataBuffer* thisPtr, RvUint32 index, RvInt8* dataPtr);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:index}   {d:The byte offset to read the value from.}}
		{param: {n:dataPtr} {d:A pointer the the variable to hold the data read from the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferWriteAtInt8 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method writes a RvInt8 into the data buffer at a specified
            byte offset. This method does not affect the buffer's front or back 
            data pointers.}
	}
	{proto: void rvDataBufferWriteAtInt8(RvDataBuffer* thisPtr, RvUint32 index, RvInt8 data);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:index}   {d:The byte offset to write the value to.}}
		{param: {n:data}    {d:The value to write into the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferReadAtUint16 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method reads a RvUint16 from the data buffer from a specified
            byte offset. This method does not affect the buffer's front or back 
            data pointers.}
	}
	{proto: void rvDataBufferReadAtUint16(RvDataBuffer* thisPtr, RvUint32 index, RvUint16* dataPtr);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:index}   {d:The byte offset to read the value from.}}
		{param: {n:dataPtr} {d:A pointer the the variable to hold the data read from the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferWriteAtUint16 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method writes a RvUint16 into the data buffer at a specified
            byte offset. This method does not affect the buffer's front or back 
            data pointers.}
	}
	{proto: void rvDataBufferWriteAtUint16(RvDataBuffer* thisPtr, RvUint32 index, RvUint16 data);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:index}   {d:The byte offset to write the value to.}}
		{param: {n:data}    {d:The value to write into the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferReadAtInt16 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method reads a RvInt16 from the data buffer from a specified
            byte offset. This method does not affect the buffer's front or back 
            data pointers.}
	}
	{proto: void rvDataBufferReadAtInt16(RvDataBuffer* thisPtr, RvUint32 index, RvInt16* dataPtr);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:index}   {d:The byte offset to read the value from.}}
		{param: {n:dataPtr} {d:A pointer the the variable to hold the data read from the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferWriteAtInt16 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method writes a RvInt16 into the data buffer at a specified
            byte offset. This method does not affect the buffer's front or back 
            data pointers.}
	}
	{proto: void rvDataBufferWriteAtInt16(RvDataBuffer* thisPtr, RvUint32 index, RvInt16 data);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:index}   {d:The byte offset to write the value to.}}
		{param: {n:data}    {d:The value to write into the buffer.}}
	}
}
$*/


/*$
{function:
	{name:    rvDataBufferReadAtUint32 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method reads a RvUint32 from the data buffer from a specified
            byte offset. This method does not affect the buffer's front or back 
            data pointers.}
	}
	{proto: void rvDataBufferReadAtUint32(RvDataBuffer* thisPtr, RvUint32 index, RvUint32* dataPtr);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:index}   {d:The byte offset to read the value from.}}
		{param: {n:dataPtr} {d:A pointer the the variable to hold the data read from the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferWriteAtUint32 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method writes a RvUint32 into the data buffer at a specified
            byte offset. This method does not affect the buffer's front or back 
            data pointers.}
	}
	{proto: void rvDataBufferWriteAtUint32(RvDataBuffer* thisPtr, RvUint32 index, RvUint32 data);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:index}   {d:The byte offset to write the value to.}}
		{param: {n:data}    {d:The value to write into the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferReadAtInt32 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method reads a RvInt32 from the data buffer from a specified
            byte offset. This method does not affect the buffer's front or back 
            data pointers.}
	}
	{proto: void rvDataBufferReadAtInt32(RvDataBuffer* thisPtr, RvUint32 index, RvInt32* dataPtr);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:index}   {d:The byte offset to read the value from.}}
		{param: {n:dataPtr} {d:A pointer the the variable to hold the data read from the buffer.}}
	}
}
$*/

/*$
{function:
	{name:    rvDataBufferWriteAtInt32 }
	{class:   RvDataBuffer}
	{include: rvdatabuffer.h}
	{description:
		{p: This method writes a RvInt32 into the data buffer at a specified
            byte offset. This method does not affect the buffer's front or back 
            data pointers.}
	}
	{proto: void rvDataBufferWriteAtInt32(RvDataBuffer* thisPtr, RvUint32 index, RvInt32 data);}
	{params:
		{param: {n:thisPtr} {d:The RvDataBuffer object.}}
		{param: {n:index}   {d:The byte offset to write the value to.}}
		{param: {n:data}    {d:The value to write into the buffer.}}
	}
}
$*/