#ifndef ArgumentDecoder_h
#define ArgumentDecoder_h
#include "ArgumentCoder.h"
#include "Attachment.h"
#include <wtf/Deque.h>
#include <wtf/TypeTraits.h>
#include <wtf/Vector.h>
namespace CoreIPC {
class DataReference;
class ArgumentDecoder {
public:
ArgumentDecoder(const uint8_t* buffer, size_t bufferSize);
ArgumentDecoder(const uint8_t* buffer, size_t bufferSize, Deque<Attachment>&);
~ArgumentDecoder();
uint64_t destinationID() const { return m_destinationID; }
bool isInvalid() const { return m_bufferPos > m_bufferEnd; }
void markInvalid() { m_bufferPos = m_bufferEnd + 1; }
bool decodeBytes(Vector<uint8_t>&);
bool decodeBytes(uint8_t*, size_t);
bool decodeBytes(DataReference&);
bool decodeBool(bool&);
bool decodeUInt32(uint32_t&);
bool decodeUInt64(uint64_t&);
bool decodeInt32(int32_t&);
bool decodeInt64(int64_t&);
bool decodeFloat(float&);
bool decodeDouble(double&);
template<typename T> bool decodeEnum(T& result)
{
COMPILE_ASSERT(sizeof(T) <= sizeof(uint64_t), enum_type_must_not_be_larger_than_64_bits);
uint64_t value;
if (!decodeUInt64(value))
return false;
result = static_cast<T>(value);
return true;
}
template<typename T>
bool bufferIsLargeEnoughToContain(size_t numElements) const
{
COMPILE_ASSERT(WTF::IsArithmetic<T>::value, type_must_have_known_encoded_size);
if (numElements > std::numeric_limits<size_t>::max() / sizeof(T))
return false;
return bufferIsLargeEnoughToContain(__alignof(T), numElements * sizeof(T));
}
template<typename T> bool decode(T& t)
{
return ArgumentCoder<T>::decode(this, t);
}
template<typename T> bool decode(const T& t)
{
return decode(const_cast<T&>(t));
}
bool removeAttachment(Attachment&);
#ifndef NDEBUG
void debug();
#endif
private:
ArgumentDecoder(const ArgumentDecoder*);
ArgumentDecoder* operator=(const ArgumentDecoder*);
void initialize(const uint8_t* buffer, size_t bufferSize);
bool alignBufferPosition(unsigned alignment, size_t size);
bool bufferIsLargeEnoughToContain(unsigned alignment, size_t size) const;
uint64_t m_destinationID;
uint8_t* m_allocatedBase;
uint8_t* m_buffer;
uint8_t* m_bufferPos;
uint8_t* m_bufferEnd;
Deque<Attachment> m_attachments;
};
template<> inline bool ArgumentDecoder::decode(bool& n)
{
return decodeBool(n);
}
template<> inline bool ArgumentDecoder::decode(uint32_t& n)
{
return decodeUInt32(n);
}
template<> inline bool ArgumentDecoder::decode(uint64_t& n)
{
return decodeUInt64(n);
}
template<> inline bool ArgumentDecoder::decode(int32_t& n)
{
return decodeInt32(n);
}
template<> inline bool ArgumentDecoder::decode(int64_t& n)
{
return decodeInt64(n);
}
template<> inline bool ArgumentDecoder::decode(float& n)
{
return decodeFloat(n);
}
template<> inline bool ArgumentDecoder::decode(double& n)
{
return decodeDouble(n);
}
}
#endif // ArgumentDecoder_h