mirror of https://github.com/JAJames/Jupiter.git
JustinAJ
10 years ago
22 changed files with 1066 additions and 17 deletions
@ -0,0 +1,121 @@ |
|||
/**
|
|||
* Copyright (C) Justin James - All Rights Reserved. |
|||
* Unauthorized use or copying of this file via any medium is strictly prohibited. |
|||
* This document is proprietary and confidential. |
|||
* This document should be immediately destroyed unless given explicit permission by Justin James. |
|||
* Written by Justin James <justin.aj@hotmail.com> |
|||
*/ |
|||
|
|||
#include <cstdlib> |
|||
#include "DataBuffer.h" |
|||
#include "Reference_String.h" |
|||
|
|||
Jupiter::DataBuffer::DataBuffer() |
|||
{ |
|||
Jupiter::DataBuffer::base = nullptr; |
|||
Jupiter::DataBuffer::head = Jupiter::DataBuffer::base; |
|||
Jupiter::DataBuffer::end = Jupiter::DataBuffer::head; |
|||
Jupiter::DataBuffer::bufferSize = 0U; |
|||
} |
|||
|
|||
Jupiter::DataBuffer::DataBuffer(size_t size_) |
|||
{ |
|||
Jupiter::DataBuffer::base = reinterpret_cast<uint8_t *>(malloc(size_)); |
|||
Jupiter::DataBuffer::head = Jupiter::DataBuffer::base; |
|||
Jupiter::DataBuffer::end = Jupiter::DataBuffer::head; |
|||
Jupiter::DataBuffer::bufferSize = size_; |
|||
} |
|||
|
|||
Jupiter::DataBuffer::~DataBuffer() |
|||
{ |
|||
free(Jupiter::DataBuffer::base); |
|||
} |
|||
|
|||
void Jupiter::DataBuffer::push(const uint8_t *data, size_t size_) |
|||
{ |
|||
Jupiter::DataBuffer::secure(size_); |
|||
fputs("Pushing: \"", stdout); |
|||
while (size_-- != 0) |
|||
{ |
|||
fputc(*data, stdout); |
|||
*Jupiter::DataBuffer::end++ = *data++; |
|||
} |
|||
puts("\""); |
|||
} |
|||
|
|||
size_t Jupiter::DataBuffer::shrink() |
|||
{ |
|||
Jupiter::DataBuffer::bufferSize = Jupiter::DataBuffer::size(); |
|||
|
|||
if (Jupiter::DataBuffer::base != Jupiter::DataBuffer::head) |
|||
memmove(Jupiter::DataBuffer::base, Jupiter::DataBuffer::head, Jupiter::DataBuffer::bufferSize); |
|||
|
|||
Jupiter::DataBuffer::base = reinterpret_cast<uint8_t *>(realloc(Jupiter::DataBuffer::base, Jupiter::DataBuffer::bufferSize)); |
|||
Jupiter::DataBuffer::head = Jupiter::DataBuffer::base; |
|||
Jupiter::DataBuffer::end = Jupiter::DataBuffer::head + Jupiter::DataBuffer::bufferSize; |
|||
return Jupiter::DataBuffer::bufferSize; |
|||
} |
|||
|
|||
size_t Jupiter::DataBuffer::expandBuffer(size_t size_) |
|||
{ |
|||
Jupiter::DataBuffer::bufferSize += size_; |
|||
size_ = Jupiter::DataBuffer::end - Jupiter::DataBuffer::head; |
|||
|
|||
if (Jupiter::DataBuffer::base != Jupiter::DataBuffer::head) |
|||
memmove(Jupiter::DataBuffer::base, Jupiter::DataBuffer::head, size_); |
|||
|
|||
Jupiter::DataBuffer::base = reinterpret_cast<uint8_t *>(realloc(Jupiter::DataBuffer::base, Jupiter::DataBuffer::bufferSize)); |
|||
Jupiter::DataBuffer::head = Jupiter::DataBuffer::base; |
|||
Jupiter::DataBuffer::end = Jupiter::DataBuffer::head + size_; |
|||
return Jupiter::DataBuffer::bufferSize; |
|||
} |
|||
|
|||
void Jupiter::DataBuffer::secure(size_t size_) |
|||
{ |
|||
size_t data_size = Jupiter::DataBuffer::end - Jupiter::DataBuffer::head; |
|||
size_ += data_size; |
|||
if (Jupiter::DataBuffer::bufferSize < size_) |
|||
{ |
|||
if (Jupiter::DataBuffer::base != Jupiter::DataBuffer::head) |
|||
memmove(Jupiter::DataBuffer::base, Jupiter::DataBuffer::head, data_size); |
|||
|
|||
Jupiter::DataBuffer::base = reinterpret_cast<uint8_t *>(realloc(Jupiter::DataBuffer::base, size_)); |
|||
Jupiter::DataBuffer::head = Jupiter::DataBuffer::base; |
|||
Jupiter::DataBuffer::end = Jupiter::DataBuffer::head + data_size; |
|||
Jupiter::DataBuffer::bufferSize = size_; |
|||
} |
|||
} |
|||
|
|||
void Jupiter::DataBuffer::setBufferSize(size_t size_) |
|||
{ |
|||
Jupiter::DataBuffer::bufferSize = size_; |
|||
size_ = Jupiter::DataBuffer::end - Jupiter::DataBuffer::head; |
|||
|
|||
if (Jupiter::DataBuffer::base != Jupiter::DataBuffer::head) |
|||
memmove(Jupiter::DataBuffer::base, Jupiter::DataBuffer::head, size_); |
|||
|
|||
Jupiter::DataBuffer::base = reinterpret_cast<uint8_t *>(realloc(Jupiter::DataBuffer::base, Jupiter::DataBuffer::bufferSize)); |
|||
Jupiter::DataBuffer::head = Jupiter::DataBuffer::base; |
|||
Jupiter::DataBuffer::end = Jupiter::DataBuffer::head + size_; |
|||
} |
|||
|
|||
size_t Jupiter::DataBuffer::size() const |
|||
{ |
|||
return Jupiter::DataBuffer::end - Jupiter::DataBuffer::head; |
|||
} |
|||
|
|||
size_t Jupiter::DataBuffer::getBufferSize() const |
|||
{ |
|||
return Jupiter::DataBuffer::bufferSize; |
|||
} |
|||
|
|||
uint8_t *Jupiter::DataBuffer::getHead() const |
|||
{ |
|||
return Jupiter::DataBuffer::head; |
|||
} |
|||
|
|||
void Jupiter::DataBuffer::empty() |
|||
{ |
|||
Jupiter::DataBuffer::head = Jupiter::DataBuffer::base; |
|||
Jupiter::DataBuffer::end = Jupiter::DataBuffer::head; |
|||
} |
|||
@ -0,0 +1,216 @@ |
|||
/**
|
|||
* Copyright (C) 2015 Justin James. |
|||
* |
|||
* This license must be preserved. |
|||
* Any applications, libraries, or code which make any use of any |
|||
* component of this program must not be commercial, unless explicit |
|||
* permission is granted from the original author. The use of this |
|||
* program for non-profit purposes is permitted. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
|||
* |
|||
* In the event that this license restricts you from making desired use of this program, contact the original author. |
|||
* Written by Justin James <justin.aj@hotmail.com> |
|||
*/ |
|||
|
|||
#if !defined _DATABUFFER_H_HEADER |
|||
#define _DATABUFFER_H_HEADER |
|||
|
|||
/**
|
|||
* @file DataBuffer.h |
|||
* @brief Defines a simple data buffer structure. |
|||
*/ |
|||
|
|||
#include <cstdint> |
|||
#include "Jupiter.h" |
|||
|
|||
namespace Jupiter |
|||
{ |
|||
/**
|
|||
* @brief Provides a data buffer implementation intended for files and sockets. |
|||
* DataBuffer behaves as a FIFO single-directional queue. |
|||
*/ |
|||
class JUPITER_API DataBuffer |
|||
{ |
|||
public: |
|||
|
|||
/**
|
|||
* @brief Generates an object based on an input head position; the head |
|||
* will be moved if the input type can be interpreted. |
|||
* |
|||
* @return Generated object. |
|||
*/ |
|||
template<typename T> static T interpret_data(uint8_t *&head); |
|||
template<template<typename> class T, typename Y> static T<Y> interpret_data(uint8_t *&head); |
|||
template<template<typename, typename> class T, typename X, typename Y> static T<X, Y> interpret_data(uint8_t *&head); |
|||
template<template<typename, typename, typename> class T, typename X, typename Y, typename Z> static T<X, Y, Z> interpret_data(uint8_t *&head); |
|||
|
|||
/**
|
|||
* @brief Copies data from the front of the buffer, without removing it. |
|||
* |
|||
* @param T Data type |
|||
* |
|||
* @return Sum of all the elements in the string |
|||
*/ |
|||
template<typename T> T peek() const; |
|||
template<template<typename> class T, typename Y> T<Y> peek() const; |
|||
template<template<typename, typename> class T, typename X, typename Y> T<X, Y> peek() const; |
|||
template<template<typename, typename, typename> class T, typename X, typename Y, typename Z> T<X, Y, Z> peek() const; |
|||
|
|||
template<typename T> void peek(T &out) const; |
|||
template<template<typename> class T, typename Y> void peek(T<Y> &out) const; |
|||
template<template<typename, typename> class T, typename X, typename Y> void peek(T<X, Y> &out) const; |
|||
template<template<typename, typename, typename> class T, typename X, typename Y, typename Z> void peek(T<X, Y, Z> &out) const; |
|||
|
|||
/**
|
|||
* @brief Copies data from the front of the buffer, without removing it. |
|||
* Note: Elements will be in the opposite order than concurrent calls |
|||
* to peek() would produce. |
|||
* |
|||
* @param T Data type |
|||
* @param size Number of elements to pop |
|||
* |
|||
* @return Sum of all the elements in the string |
|||
*/ |
|||
template<typename T> T *peek(size_t size) const; |
|||
|
|||
/**
|
|||
* @brief Copies data from the front of the buffer and removes it. |
|||
* |
|||
* @param T Data type |
|||
* |
|||
* @return Sum of all the elements in the string |
|||
*/ |
|||
template<typename T> T pop(); |
|||
template<template<typename> class T, typename Y> T<Y> pop(); |
|||
template<template<typename, typename> class T, typename X, typename Y> T<X, Y> pop(); |
|||
template<template<typename, typename, typename> class T, typename X, typename Y, typename Z> T<X, Y, Z> pop(); |
|||
|
|||
template<typename T> void pop(T &out); |
|||
template<template<typename> class T, typename Y> void pop(T<Y> &out); |
|||
template<template<typename, typename> class T, typename X, typename Y> void pop(T<X, Y> &out); |
|||
template<template<typename, typename, typename> class T, typename X, typename Y, typename Z> void pop(T<X, Y, Z> &out); |
|||
|
|||
/**
|
|||
* @brief Copies data from the front of the buffer and removes it. |
|||
* Note: Elements will be in the opposite order than concurrent calls |
|||
* to pop() would produce. |
|||
* |
|||
* @param T Data type |
|||
* @param size Number of elements to pop |
|||
* |
|||
* @return Sum of all the elements in the string |
|||
*/ |
|||
template<typename T> T *pop(size_t size); |
|||
|
|||
/**
|
|||
* @brief Adds data to the front of the buffer. |
|||
* |
|||
* @param T Data type |
|||
* @param data Data to add to the buffer |
|||
*/ |
|||
template<typename T> void push(const T *data); |
|||
template<typename T> void push(const T &data); |
|||
|
|||
// Specialization: Jupiter::ReadableString + Sub classes
|
|||
template<template<typename> class T, typename Y> void push(const T<Y> *data); |
|||
template<template<typename> class T, typename Y> void push(const T<Y> &data); |
|||
|
|||
// SPECIALIZATION TODO: std::deque - std::list - std::forward_list
|
|||
|
|||
// SPECIALIZATION: std::array
|
|||
template<template<typename, size_t> class T, typename X, size_t Y> void push(const T<X, Y> *data); |
|||
template<template<typename, size_t> class T, typename X, size_t Y> void push(const T<X, Y> &data); |
|||
|
|||
// SPECIALIZATION: std::vector
|
|||
template<template<typename, typename> class T, typename X, typename Y> void push(const T<X, Y> *data); |
|||
template<template<typename, typename> class T, typename X, typename Y> void push(const T<X, Y> &data); |
|||
|
|||
// SPECIALIZATION: std::basic_string (std::string / std::wstring / etc)
|
|||
template<template<typename, typename, typename> class T, typename X, typename Y, typename Z> void push(const T<X, Y, Z> *data); |
|||
template<template<typename, typename, typename> class T, typename X, typename Y, typename Z> void push(const T<X, Y, Z> &data); |
|||
|
|||
/**
|
|||
* @brief Adds data to the end of the buffer. |
|||
* |
|||
* @param data Data to add to the buffer |
|||
* @param size Number of octets in data to add |
|||
*/ |
|||
void push(const uint8_t *data, size_t size); |
|||
|
|||
/**
|
|||
* @brief Shrinks the buffer to the smallest possible size. |
|||
* |
|||
* @return New size of the buffer in octets. |
|||
*/ |
|||
size_t shrink(); |
|||
|
|||
/**
|
|||
* @brief Expands the size of the internal buffer by a set number of octets. |
|||
* |
|||
* @param size Number of octets to |
|||
* @return New size of the buffer in octets. |
|||
*/ |
|||
size_t expandBuffer(size_t size); |
|||
|
|||
/**
|
|||
* @brief Guarantees availability for a specified number of octets. |
|||
* |
|||
* @param size Number of octets to guarantee. |
|||
* @return New size of the buffer in octets. |
|||
*/ |
|||
void secure(size_t size); |
|||
|
|||
/**
|
|||
* @brief Sets the size of the internal buffer. |
|||
* Note: If input 'size' is less than size(), data is removed. |
|||
* |
|||
* @param size Size to set the buffer to. |
|||
* @return New size of the buffer in octets. |
|||
*/ |
|||
void setBufferSize(size_t size); |
|||
|
|||
/**
|
|||
* @brief Fetches the size of the data in octets. |
|||
* |
|||
* @return Size of the data in octets. |
|||
*/ |
|||
size_t size() const; |
|||
|
|||
/**
|
|||
* @brief Fetches the size of the buffer in octets. |
|||
* |
|||
* @return Size of the buffer in octets. |
|||
*/ |
|||
size_t getBufferSize() const; |
|||
|
|||
/**
|
|||
* @brief Fetches the head of the buffer |
|||
* |
|||
* @return Buffer head |
|||
*/ |
|||
uint8_t *getHead() const; |
|||
|
|||
/**
|
|||
* @brief Empties the buffer of all elements. |
|||
* Note: The internal memory buffer is not freed or reallocated. |
|||
*/ |
|||
void empty(); |
|||
|
|||
DataBuffer(); |
|||
DataBuffer(size_t size); |
|||
~DataBuffer(); |
|||
|
|||
private: |
|||
uint8_t *base; |
|||
uint8_t *head; |
|||
uint8_t *end; |
|||
size_t bufferSize; |
|||
}; |
|||
} |
|||
|
|||
#include "DataBuffer_Imp.h" |
|||
|
|||
#endif // _DATABUFFER_H_HEADER
|
|||
@ -0,0 +1,350 @@ |
|||
/**
|
|||
* Copyright (C) 2015 Justin James. |
|||
* |
|||
* This license must be preserved. |
|||
* Any applications, libraries, or code which make any use of any |
|||
* component of this program must not be commercial, unless explicit |
|||
* permission is granted from the original author. The use of this |
|||
* program for non-profit purposes is permitted. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
|||
* |
|||
* In the event that this license restricts you from making desired use of this program, contact the original author. |
|||
* Written by Justin James <justin.aj@hotmail.com> |
|||
*/ |
|||
|
|||
#if !defined _DATABUFFER_IMP_H_HEADER |
|||
#define _DATABUFFER_IMP_H_HEADER |
|||
|
|||
/**
|
|||
* @file DataBuffer_Imp.h |
|||
* @brief Provides the implementations for DataBuffer template functions. |
|||
* Note: Modification of this file is not supported in any way. |
|||
*/ |
|||
|
|||
#include <vector> |
|||
#include <array> |
|||
|
|||
/**
|
|||
* IMPLEMENTATION: |
|||
* DataBuffer |
|||
*/ |
|||
|
|||
template<typename T> T Jupiter::DataBuffer::interpret_data(uint8_t *&head) |
|||
{ |
|||
T r = T(*(reinterpret_cast<T *>(head))); |
|||
head += sizeof(T); |
|||
return r; |
|||
} |
|||
|
|||
template<template<typename> class T, typename Y> static T<Y> interpret_data(uint8_t *&head) |
|||
{ |
|||
return _Jupiter_DataBuffer_partial_specialization_impl_std<T>::interpret<Y>(head); |
|||
} |
|||
|
|||
template<template<typename, typename> class T, typename X, typename Y> static T<X, Y> interpret_data(uint8_t *&head) |
|||
{ |
|||
return _Jupiter_DataBuffer_partial_specialization_impl_std_vector<T>::interpret<X, Y>(head); |
|||
} |
|||
|
|||
template<template<typename, typename, typename> class T, typename X, typename Y, typename Z> static T<X, Y, Z> interpret_data(uint8_t *&head) |
|||
{ |
|||
return _Jupiter_DataBuffer_partial_specialization_impl_std_string<T>::interpret<X, Y, Z>(head); |
|||
} |
|||
|
|||
// Basic peek
|
|||
|
|||
template<typename T> T Jupiter::DataBuffer::peek() const |
|||
{ |
|||
uint8_t *ptr = Jupiter::DataBuffer::head; |
|||
return Jupiter::DataBuffer::interpret_data<T>(ptr); |
|||
} |
|||
|
|||
template<template<typename> class T, typename Y> T<Y> Jupiter::DataBuffer::peek() const |
|||
{ |
|||
uint8_t *ptr = Jupiter::DataBuffer::head; |
|||
return Jupiter::DataBuffer::interpret_data<T, Y>(ptr); |
|||
} |
|||
|
|||
template<template<typename, typename> class T, typename X, typename Y> T<X, Y> Jupiter::DataBuffer::peek() const |
|||
{ |
|||
uint8_t *ptr = Jupiter::DataBuffer::head; |
|||
return Jupiter::DataBuffer::interpret_data<T, X, Y>(ptr); |
|||
} |
|||
|
|||
template<template<typename, typename, typename> class T, typename X, typename Y, typename Z> T<X, Y, Z> Jupiter::DataBuffer::peek() const |
|||
{ |
|||
uint8_t *ptr = Jupiter::DataBuffer::head; |
|||
return Jupiter::DataBuffer::interpret_data<T, X, Y, Z>(ptr); |
|||
} |
|||
|
|||
template<typename T> void Jupiter::DataBuffer::peek(T &out) const |
|||
{ |
|||
out = Jupiter::DataBuffer::peek<T>(); |
|||
} |
|||
|
|||
template<template<typename> class T, typename Y> void Jupiter::DataBuffer::peek(T<Y> &out) const |
|||
{ |
|||
out = Jupiter::DataBuffer::peek<T, Y>(); |
|||
} |
|||
|
|||
template<template<typename, typename> class T, typename X, typename Y> void Jupiter::DataBuffer::peek(T<X, Y> &out) const |
|||
{ |
|||
out = Jupiter::DataBuffer::peek<T, X, Y>(); |
|||
} |
|||
|
|||
template<template<typename, typename, typename> class T, typename X, typename Y, typename Z> void Jupiter::DataBuffer::peek(T<X, Y, Z> &out) const |
|||
{ |
|||
out = Jupiter::DataBuffer::peek<T, X, Y, Z>(); |
|||
} |
|||
|
|||
template<typename T> T *Jupiter::DataBuffer::peek(size_t size_) const |
|||
{ |
|||
uint8_t *ptr = Jupiter::DataBuffer::head; |
|||
T *r = new T[size_]; |
|||
T *itr = r; |
|||
while (size_-- != 0) |
|||
*itr++ = Jupiter::DataBuffer::interpret_data<T>(ptr); |
|||
return r; |
|||
} |
|||
|
|||
// Basic pop
|
|||
|
|||
template<typename T> T Jupiter::DataBuffer::pop() |
|||
{ |
|||
return Jupiter::DataBuffer::interpret_data<T>(Jupiter::DataBuffer::head); |
|||
} |
|||
|
|||
template<template<typename> class T, typename Y> T<Y> Jupiter::DataBuffer::pop() |
|||
{ |
|||
return Jupiter::DataBuffer::interpret_data<T, Y>(Jupiter::DataBuffer::head); |
|||
} |
|||
|
|||
template<template<typename, typename> class T, typename X, typename Y> T<X, Y> Jupiter::DataBuffer::pop() |
|||
{ |
|||
return Jupiter::DataBuffer::interpret_data<T, X, Y>(Jupiter::DataBuffer::head); |
|||
} |
|||
|
|||
template<template<typename, typename, typename> class T, typename X, typename Y, typename Z> T<X, Y, Z> Jupiter::DataBuffer::pop() |
|||
{ |
|||
return Jupiter::DataBuffer::interpret_data<T, X, Y, Z>(Jupiter::DataBuffer::head); |
|||
} |
|||
|
|||
template<typename T> void Jupiter::DataBuffer::pop(T &out) |
|||
{ |
|||
out = Jupiter::DataBuffer::pop<T>(); |
|||
} |
|||
|
|||
template<template<typename> class T, typename Y> void Jupiter::DataBuffer::pop(T<Y> &out) |
|||
{ |
|||
out = Jupiter::DataBuffer::pop<T, Y>(); |
|||
} |
|||
|
|||
template<template<typename, typename> class T, typename X, typename Y> void Jupiter::DataBuffer::pop(T<X, Y> &out) |
|||
{ |
|||
out = Jupiter::DataBuffer::pop<T, X, Y>(); |
|||
} |
|||
|
|||
template<template<typename, typename, typename> class T, typename X, typename Y, typename Z> void Jupiter::DataBuffer::pop(T<X, Y, Z> &out) |
|||
{ |
|||
out = Jupiter::DataBuffer::pop<T, X, Y, Z>(); |
|||
} |
|||
|
|||
template<typename T> T *Jupiter::DataBuffer::pop(size_t size_) |
|||
{ |
|||
T *r = new T[size_]; |
|||
T *itr = r; |
|||
while (size_-- != 0) |
|||
*itr++ = Jupiter::DataBuffer::interpret_data<T>(Jupiter::DataBuffer::head); |
|||
return r; |
|||
} |
|||
|
|||
// Basic push
|
|||
|
|||
template<typename T> void Jupiter::DataBuffer::push(const T *data) |
|||
{ |
|||
Jupiter::DataBuffer::secure(sizeof(T)); |
|||
*reinterpret_cast<T *>(Jupiter::DataBuffer::end) = *data; |
|||
Jupiter::DataBuffer::end += sizeof(T); |
|||
} |
|||
|
|||
template<typename T> void Jupiter::DataBuffer::push(const T &data) |
|||
{ |
|||
Jupiter::DataBuffer::push<T>(&data); |
|||
} |
|||
|
|||
// SPECIALIZATION: Jupiter::DataBuffer
|
|||
|
|||
template<> void inline Jupiter::DataBuffer::push(const Jupiter::DataBuffer *data) |
|||
{ |
|||
size_t size_ = data->size(); |
|||
Jupiter::DataBuffer::secure(sizeof(size_t) + size_); |
|||
Jupiter::DataBuffer::push<size_t>(size_); |
|||
Jupiter::DataBuffer::push(data->getHead(), size_); |
|||
} |
|||
|
|||
template<> Jupiter::DataBuffer inline Jupiter::DataBuffer::interpret_data(uint8_t *&head_) |
|||
{ |
|||
size_t size_ = *reinterpret_cast<size_t *>(head_); |
|||
head_ += sizeof(size_t); |
|||
Jupiter::DataBuffer r = Jupiter::DataBuffer(size_); |
|||
while (size_-- != 0) |
|||
*r.end++ = *head_++; |
|||
return r; |
|||
} |
|||
|
|||
// template / string push
|
|||
|
|||
template<template<typename> class T> struct _Jupiter_DataBuffer_partial_specialization_impl |
|||
{ |
|||
}; |
|||
|
|||
template<template<typename> class T, typename Y> void Jupiter::DataBuffer::push(const T<Y> *data) |
|||
{ |
|||
_Jupiter_DataBuffer_partial_specialization_impl<T>::push<Y>(this, data); |
|||
} |
|||
|
|||
template<template<typename> class T, typename Y> void Jupiter::DataBuffer::push(const T<Y> &data) |
|||
{ |
|||
Jupiter::DataBuffer::push<T, Y>(&data); |
|||
} |
|||
|
|||
template<template<typename> class T, typename Y> T<Y> Jupiter::DataBuffer::interpret_data(uint8_t *&head) |
|||
{ |
|||
return _Jupiter_DataBuffer_partial_specialization_impl<T>::interpret<Y>(head); |
|||
} |
|||
|
|||
// PUSH SPECIALIZATION: std::array
|
|||
|
|||
template<template<typename, size_t> class T> struct _Jupiter_DataBuffer_partial_specialization_impl_std_array |
|||
{ |
|||
}; |
|||
|
|||
template<> struct _Jupiter_DataBuffer_partial_specialization_impl_std_array<std::array> |
|||
{ |
|||
template<typename X, size_t Y> static void push(Jupiter::DataBuffer *buffer, const std::array<X, Y> *data) |
|||
{ |
|||
buffer->push<size_t>(Y); |
|||
if (std::is_fundamental<std::array<X, Y>::value_type>::value) |
|||
buffer->push(reinterpret_cast<const uint8_t *>(data->data()), data->size() * sizeof(std::array<X, Y>::value_type)); |
|||
else |
|||
{ |
|||
std::array<X, Y>::const_iterator itr = data->begin(); |
|||
std::array<X, Y>::const_iterator end = data->end(); |
|||
while (itr != end) |
|||
buffer->push<std::array<X, Y>::value_type>(*itr++); |
|||
} |
|||
}; |
|||
}; |
|||
|
|||
template<template<typename, size_t> class T, typename X, size_t Y> void Jupiter::DataBuffer::push(const T<X, Y> *data) |
|||
{ |
|||
_Jupiter_DataBuffer_partial_specialization_impl_std_array<T>::push<X, Y>(this, data); |
|||
} |
|||
|
|||
template<template<typename, size_t> class T, typename X, size_t Y> void Jupiter::DataBuffer::push(const T<X, Y> &data) |
|||
{ |
|||
Jupiter::DataBuffer::push<T, X, Y>(&data); |
|||
} |
|||
|
|||
// SPECIALIZATION: std::vector
|
|||
|
|||
template<template<typename, typename> class T> struct _Jupiter_DataBuffer_partial_specialization_impl_std_vector |
|||
{ |
|||
}; |
|||
|
|||
template<> struct _Jupiter_DataBuffer_partial_specialization_impl_std_vector<std::vector> |
|||
{ |
|||
template<typename X, typename Y> static void push(Jupiter::DataBuffer *buffer, const std::vector<X, Y> *data) |
|||
{ |
|||
buffer->push<std::vector<X, Y>::size_type>(data->size()); |
|||
if (std::is_fundamental<std::vector<X, Y>::value_type>::value) |
|||
buffer->push(reinterpret_cast<const uint8_t *>(data->data()), data->size() * sizeof(std::vector<X, Y>::value_type)); |
|||
else |
|||
{ |
|||
std::vector<X, Y>::const_iterator itr = data->begin(); |
|||
std::vector<X, Y>::const_iterator end = data->end(); |
|||
while (itr != end) |
|||
buffer->push<std::vector<X, Y>::value_type>(*itr++); |
|||
} |
|||
}; |
|||
|
|||
template<typename X, typename Y> static std::vector<X, Y> interpret(uint8_t *&head) |
|||
{ |
|||
size_t size_ = *reinterpret_cast<size_t *>(head); |
|||
head += sizeof(size_t); |
|||
std::vector<X, Y> r; |
|||
r.reserve(size_); |
|||
while (size_-- != 0) |
|||
r.push_back(Jupiter::DataBuffer::interpret_data<std::vector<X, Y>::value_type>(head)); |
|||
return r; |
|||
} |
|||
}; |
|||
|
|||
template<template<typename, typename> class T, typename X, typename Y> void Jupiter::DataBuffer::push(const T<X, Y> *data) |
|||
{ |
|||
_Jupiter_DataBuffer_partial_specialization_impl_std_vector<T>::push<X, Y>(this, data); |
|||
} |
|||
|
|||
template<template<typename, typename> class T, typename X, typename Y> void Jupiter::DataBuffer::push(const T<X, Y> &data) |
|||
{ |
|||
Jupiter::DataBuffer::push<T, X, Y>(&data); |
|||
} |
|||
|
|||
template<template<typename, typename> class T, typename X, typename Y> T<X, Y> Jupiter::DataBuffer::interpret_data(uint8_t *&head) |
|||
{ |
|||
return _Jupiter_DataBuffer_partial_specialization_impl_std_vector<T>::interpret<X, Y>(head); |
|||
} |
|||
|
|||
// SPECIALIZATION: std::string
|
|||
|
|||
template<template<typename, typename, typename> class T> struct _Jupiter_DataBuffer_partial_specialization_impl_std_string |
|||
{ |
|||
}; |
|||
|
|||
template<> struct _Jupiter_DataBuffer_partial_specialization_impl_std_string<std::basic_string> |
|||
{ |
|||
template<typename X, typename Y, typename Z> static void push(Jupiter::DataBuffer *buffer, const std::basic_string<X, Y, Z> *data) |
|||
{ |
|||
buffer->push(data->size()); |
|||
if (std::is_fundamental<std::basic_string<X, Y, Z>::value_type>::value) |
|||
buffer->push(reinterpret_cast<const uint8_t *>(data->data()), data->size() * sizeof(X)); |
|||
else |
|||
{ |
|||
std::basic_string<X, Y, Z>::const_iterator itr = data->begin(); |
|||
std::basic_string<X, Y, Z>::const_iterator end = data->end(); |
|||
while (itr != end) |
|||
buffer->push<std::basic_string<X, Y, Z>::value_type>(*itr++); |
|||
} |
|||
}; |
|||
|
|||
template<typename X, typename Y, typename Z> static std::basic_string<X, Y, Z> interpret(uint8_t *&head) |
|||
{ |
|||
size_t size_ = *reinterpret_cast<size_t *>(head); |
|||
head += sizeof(size_t); |
|||
std::basic_string<X, Y, Z> r; |
|||
r.reserve(size_); |
|||
while (size_-- != 0) |
|||
r.push_back(Jupiter::DataBuffer::interpret_data<std::basic_string<X, Y, Z>::value_type>(head)); |
|||
return r; |
|||
} |
|||
}; |
|||
|
|||
template<template<typename, typename, typename> class T, typename X, typename Y, typename Z> void Jupiter::DataBuffer::push(const T<X, Y, Z> *data) |
|||
{ |
|||
_Jupiter_DataBuffer_partial_specialization_impl_std_string<T>::push<X, Y, Z>(this, data); |
|||
} |
|||
|
|||
template<template<typename, typename, typename> class T, typename X, typename Y, typename Z> void Jupiter::DataBuffer::push(const T<X, Y, Z> &data) |
|||
{ |
|||
Jupiter::DataBuffer::push<T, X, Y, Z>(&data); |
|||
} |
|||
|
|||
template<template<typename, typename, typename> class T, typename X, typename Y, typename Z> T<X, Y, Z> Jupiter::DataBuffer::interpret_data(uint8_t *&head) |
|||
{ |
|||
return _Jupiter_DataBuffer_partial_specialization_impl_std_string<T>::interpret<X, Y, Z>(head); |
|||
} |
|||
|
|||
#endif // _DATABUFFER_IMP_H_HEADER
|
|||
Binary file not shown.
Loading…
Reference in new issue