ac_buffer_builder.h

00001 /*
00002  * Copyright (c) 2017, ARM Limited, All Rights Reserved
00003  * SPDX-License-Identifier: Apache-2.0
00004  *
00005  * Licensed under the Apache License, Version 2.0 (the "License"); you may
00006  * not use this file except in compliance with the License.
00007  * You may obtain a copy of the License at
00008  *
00009  * http://www.apache.org/licenses/LICENSE-2.0
00010  *
00011  * Unless required by applicable law or agreed to in writing, software
00012  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
00013  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00014  * See the License for the specific language governing permissions and
00015  * limitations under the License.
00016  */
00017 /**
00018  * \file ac_buffer_builder.h
00019  * \copyright Copyright (c) ARM Ltd 2017
00020  * \author Donatien Garnier
00021  */
00022 
00023 /** \addtogroup ACore
00024  *  @{
00025  *  \name Buffer Builder
00026  *  @{
00027  */
00028 
00029 #ifndef ACORE_BUFFER_BUILDER_H_
00030 #define ACORE_BUFFER_BUILDER_H_
00031 
00032 #ifdef __cplusplus
00033 extern "C" {
00034 #endif
00035 
00036 #include "stdint.h"
00037 #include "stddef.h"
00038 #include "stdbool.h"
00039 
00040 #include "acore/ac_buffer.h"
00041 
00042 typedef struct __ac_buffer_builder {
00043     ac_buffer_t ac_buffer;
00044     uint8_t *data;
00045     size_t size;
00046 } ac_buffer_builder_t;
00047 
00048 /** Write data to big endian ac_buffer (on a LE architecture, byte order will be swapped)
00049  * \param pBuilder ac_buffer builder to use
00050  * \param buf pointer to data
00051  * \param size the data size
00052  */
00053 void ac_buffer_builder_write_be(ac_buffer_builder_t *pBuilder, const uint8_t *buf, size_t size);
00054 
00055 /** Write data to little endian ac_buffer (on a LE architecture, byte order will be preserved)
00056  * \param pBuilder ac_buffer builder to use
00057  * \param buf pointer to data
00058  * \param size the data size
00059  */
00060 void ac_buffer_builder_write_le(ac_buffer_builder_t *pBuilder, const uint8_t *buf, size_t size);
00061 
00062 /** Write data to big endian ac_buffer at specific position (on a LE architecture, byte order will be swapped)
00063  * \param pBuilder ac_buffer builder to use
00064  * \param pos position in ac_buffer to write from
00065  * \param buf pointer to data
00066  * \param size the data size
00067  */
00068 void ac_buffer_builder_write_be_at(ac_buffer_builder_t *pBuilder, size_t pos, const uint8_t *buf, size_t size);
00069 
00070 /** Write data to little endian ac_buffer at specific position (on a LE architecture, byte order will be preserved)
00071  * \param pBuilder ac_buffer builder to use
00072  * \param pos position in ac_buffer to write from
00073  * \param buf pointer to data
00074  * \param size the data size
00075  */
00076 void ac_buffer_builder_write_le_at(ac_buffer_builder_t *pBuilder, size_t pos, const uint8_t *buf, size_t size);
00077 
00078 /** Initialize ac_buffer builder
00079  * \param pBuilder ac_buffer builder to init
00080  * \param data pointer to byte array to use
00081  * \param size of byte array
00082  */
00083 void ac_buffer_builder_init(ac_buffer_builder_t *pBuilder, uint8_t *data, size_t size);
00084 
00085 /** Initialize ac_buffer builder from underlying ac_buffer
00086  * \param pBuilder ac_buffer builder to init
00087  */
00088 void ac_buffer_builder_from_buffer(ac_buffer_builder_t *pBuilder);
00089 
00090 /** Reset ac_buffer builder
00091  * \param pBuilder ac_buffer builder to reset
00092  */
00093 void ac_buffer_builder_reset(ac_buffer_builder_t *pBuilder);
00094 
00095 /** Set ac_buffer builder's ac_buffer to full size
00096  * \param pBuilder ac_buffer builder to set to full size
00097  */
00098 void ac_buffer_builder_set_full(ac_buffer_builder_t *pBuilder);
00099 
00100 /** Get ac_buffer builder's length
00101  * \param pBuilder ac_buffer builder to get length of
00102  * \return number of valid bytes in ac_buffer
00103  */
00104 static inline size_t ac_buffer_builder_length(ac_buffer_builder_t *pBuilder)
00105 {
00106     return ac_buffer_size(&pBuilder->ac_buffer);
00107 }
00108 
00109 /** Set ac_buffer builder's length
00110  * \param pBuilder ac_buffer builder to set length of
00111  * \param length number of valid bytes in ac_buffer
00112  */
00113 static inline void ac_buffer_builder_set_length(ac_buffer_builder_t *pBuilder, size_t length)
00114 {
00115     if (ac_buffer_data(&pBuilder->ac_buffer) + length > pBuilder->data + pBuilder->size) {
00116         return;
00117     }
00118     pBuilder->ac_buffer.size = length;
00119 }
00120 
00121 /** Get ac_buffer builder's pointer to write position
00122  * \param pBuilder ac_buffer builder
00123  * \return pointer to write position
00124  */
00125 static inline uint8_t *ac_buffer_builder_write_position(ac_buffer_builder_t *pBuilder)
00126 {
00127     return (uint8_t *)ac_buffer_data(&pBuilder->ac_buffer) + ac_buffer_size(&pBuilder->ac_buffer);
00128 }
00129 
00130 /** Get ac_buffer builder's write offset
00131  * \param pBuilder ac_buffer builder
00132  * \return write offset
00133  */
00134 static inline size_t ac_buffer_builder_write_offset(ac_buffer_builder_t *pBuilder)
00135 {
00136     return ac_buffer_data(&pBuilder->ac_buffer) + ac_buffer_size(&pBuilder->ac_buffer) - pBuilder->data;
00137 }
00138 
00139 /** Set ac_buffer builder's write offset
00140  * \param pBuilder ac_buffer builder
00141  * \param off new write offset
00142  */
00143 static inline void ac_buffer_builder_set_write_offset(ac_buffer_builder_t *pBuilder, size_t off)
00144 {
00145     if (off > pBuilder->size) {
00146         return;
00147     }
00148     if (pBuilder->data + off > pBuilder->ac_buffer.data) {
00149         pBuilder->ac_buffer.size = off - (pBuilder->ac_buffer.data - pBuilder->data);
00150     } else {
00151         pBuilder->ac_buffer.size = 0;
00152     }
00153 }
00154 
00155 /** Get ac_buffer builder's read offset
00156  * \param pBuilder ac_buffer builder
00157  * \return read offset
00158  */
00159 static inline size_t ac_buffer_builder_read_offset(ac_buffer_builder_t *pBuilder)
00160 {
00161     return ac_buffer_data(&pBuilder->ac_buffer) - pBuilder->data;
00162 }
00163 
00164 /** Set ac_buffer builder's read offset
00165  * \param pBuilder ac_buffer builder
00166  * \param off new read offset
00167  */
00168 static inline void ac_buffer_builder_set_read_offset(ac_buffer_builder_t *pBuilder, size_t off)
00169 {
00170     if (off > pBuilder->size) {
00171         return;
00172     }
00173     if (pBuilder->data + off < pBuilder->ac_buffer.data + pBuilder->ac_buffer.size) {
00174         pBuilder->ac_buffer.size = pBuilder->ac_buffer.data - (pBuilder->data + off);
00175     } else {
00176         pBuilder->ac_buffer.size = 0;
00177     }
00178     pBuilder->ac_buffer.data = pBuilder->data + off;
00179 }
00180 
00181 /** Get ac_buffer builder's underlying ac_buffer
00182  * \param pBuilder ac_buffer builder
00183  * \return ac_buffer
00184  */
00185 static inline ac_buffer_t *ac_buffer_builder_buffer(ac_buffer_builder_t *pBuilder)
00186 {
00187     return &pBuilder->ac_buffer;
00188 }
00189 
00190 /** Get space in ac_buffer builder
00191  * \param pBuilder ac_buffer builder
00192  * \return number of free bytes in ac_buffer builder
00193  */
00194 static inline size_t ac_buffer_builder_space(ac_buffer_builder_t *pBuilder)
00195 {
00196     return pBuilder->size - (ac_buffer_data(&pBuilder->ac_buffer) - pBuilder->data + ac_buffer_size(&pBuilder->ac_buffer));
00197 }
00198 
00199 /** Is ac_buffer builder empty
00200  * \param pBuilder ac_buffer builder
00201  * \return true if ac_buffer builder is empty
00202  */
00203 static inline bool ac_buffer_builder_empty(ac_buffer_builder_t *pBuilder)
00204 {
00205     return (ac_buffer_builder_length(pBuilder) == 0);
00206 }
00207 
00208 /** Is ac_buffer builder full
00209  * \param pBuilder ac_buffer builder
00210  * \return true if ac_buffer builder is full
00211  */
00212 static inline bool ac_buffer_full(ac_buffer_builder_t *pBuilder)
00213 {
00214     return (ac_buffer_builder_space(pBuilder) == 0);
00215 }
00216 
00217 /** Write 8-bit value in ac_buffer builder
00218  * \param pBuilder ac_buffer builder
00219  * \param hu8 8-bit value to write
00220  */
00221 static inline void ac_buffer_builder_write_nu8(ac_buffer_builder_t *pBuilder, uint8_t hu8)
00222 {
00223     ac_buffer_builder_write_be(pBuilder, &hu8, 1);
00224 }
00225 
00226 /** Write 16-bit value in ac_buffer builder
00227  * \param pBuilder ac_buffer builder
00228  * \param hu16 16-bit value to write in big-endian format
00229  */
00230 static inline void ac_buffer_builder_write_nu16(ac_buffer_builder_t *pBuilder, uint16_t hu16)
00231 {
00232     ac_buffer_builder_write_be(pBuilder, (uint8_t *)&hu16, 2);
00233 }
00234 
00235 /** Write 24-bit value in ac_buffer builder
00236  * \param pBuilder ac_buffer builder
00237  * \param hu24 24-bit value to write in big-endian format
00238  */
00239 static inline void ac_buffer_builder_write_nu24(ac_buffer_builder_t *pBuilder, uint32_t hu24)
00240 {
00241     ac_buffer_builder_write_be(pBuilder, (uint8_t *)&hu24, 3);
00242 }
00243 
00244 /** Write 32-bit value in ac_buffer builder
00245  * \param pBuilder ac_buffer builder
00246  * \param hu32 32-bit value to write in big-endian format
00247  */
00248 static inline void ac_buffer_builder_write_nu32(ac_buffer_builder_t *pBuilder, uint32_t hu32)
00249 {
00250     ac_buffer_builder_write_be(pBuilder, (uint8_t *)&hu32, 4);
00251 }
00252 
00253 /** Write 64-bit value in ac_buffer builder
00254  * \param pBuilder ac_buffer builder
00255  * \param hu64 64-bit value to write in big-endian format
00256  */
00257 static inline void ac_buffer_builder_write_nu64(ac_buffer_builder_t *pBuilder, uint64_t hu64)
00258 {
00259     ac_buffer_builder_write_be(pBuilder, (uint8_t *)&hu64, 8);
00260 }
00261 
00262 /** Write n-bytes value in ac_buffer builder
00263  * \param pBuilder ac_buffer builder
00264  * \param data data to write
00265  * \param size data length
00266  */
00267 static inline void ac_buffer_builder_write_n_bytes(ac_buffer_builder_t *pBuilder, const uint8_t *data, size_t size)
00268 {
00269     ac_buffer_builder_write_le(pBuilder, data, size);
00270 }
00271 
00272 /** Write 8-bit value in ac_buffer builder at specified position
00273  * \param pBuilder ac_buffer builder
00274  * \param off offset at which to write
00275  * \param hu8 8-bit value to write
00276  */
00277 static inline void ac_buffer_builder_write_nu8_at(ac_buffer_builder_t *pBuilder, size_t off, uint8_t hu8)
00278 {
00279     ac_buffer_builder_write_be_at(pBuilder, off, &hu8, 1);
00280 }
00281 
00282 /** Write 16-bit value in ac_buffer builder at specified position
00283  * \param pBuilder ac_buffer builder
00284  * \param off offset at which to write
00285  * \param hu16 16-bit value to write
00286  */
00287 static inline void ac_buffer_builder_write_nu16_at(ac_buffer_builder_t *pBuilder, size_t off, uint16_t hu16)
00288 {
00289     ac_buffer_builder_write_be_at(pBuilder, off, (uint8_t *)&hu16, 2);
00290 }
00291 
00292 /** Write 24-bit value in ac_buffer builder at specified position
00293  * \param pBuilder ac_buffer builder
00294  * \param off offset at which to write
00295  * \param hu24 24-bit value to write
00296  */
00297 static inline void ac_buffer_builder_write_nu24_at(ac_buffer_builder_t *pBuilder, size_t off, uint32_t hu24)
00298 {
00299     ac_buffer_builder_write_be_at(pBuilder, off, (uint8_t *)&hu24, 3);
00300 }
00301 
00302 /** Write 32-bit value in ac_buffer builder at specified position
00303  * \param pBuilder ac_buffer builder
00304  * \param off offset at which to write
00305  * \param hu32 32-bit value to write
00306  */
00307 static inline void ac_buffer_builder_write_nu32_at(ac_buffer_builder_t *pBuilder, size_t off, uint32_t hu32)
00308 {
00309     ac_buffer_builder_write_be_at(pBuilder, off, (uint8_t *)&hu32, 4);
00310 }
00311 
00312 /** Write 64-bit value in ac_buffer builder at specified position
00313  * \param pBuilder ac_buffer builder
00314  * \param off offset at which to write
00315  * \param hu64 64-bit value to write
00316  */
00317 static inline void ac_buffer_builder_write_nu64_at(ac_buffer_builder_t *pBuilder, size_t off, uint64_t hu64)
00318 {
00319     ac_buffer_builder_write_be_at(pBuilder, off, (uint8_t *)&hu64, 8);
00320 }
00321 
00322 /** Write n-bytes value in ac_buffer builder at specified position
00323  * \param pBuilder ac_buffer builder
00324  * \param off offset at which to write
00325  * \param data data to write
00326  * \param size data length
00327  */
00328 static inline void ac_buffer_builder_write_n_bytes_at(ac_buffer_builder_t *pBuilder, size_t off, const uint8_t *data, size_t size)
00329 {
00330     ac_buffer_builder_write_be_at(pBuilder, off, data, size);
00331 }
00332 
00333 /** Skip n-bytes in ac_buffer builder
00334  * \param pBuilder ac_buffer builder
00335  * \param size number of bytes to skip
00336  */
00337 void ac_buffer_builder_write_n_skip(ac_buffer_builder_t *pBuilder, size_t size);
00338 
00339 /** Copy n bytes from buffer to builder
00340  * \param pBuilderOut ac_buffer builder
00341  * \param pBufIn the input buffer
00342  * \param size number of bytes to copy
00343  */
00344 void ac_buffer_builder_copy_n_bytes(ac_buffer_builder_t *pBuilderOut, ac_buffer_t *pBufIn, size_t size);
00345 
00346 /** Compact builder
00347  * Will move underlying buffer's byte to start of allocated buffer
00348  * \param pBuilder ac_buffer builder
00349  */
00350 void ac_buffer_builder_compact(ac_buffer_builder_t *pBuilder);
00351 
00352 /** Get number of writable bytes in ac_buffer builder
00353  * \param pBuilder ac_buffer builder
00354  * \return number of free bytes in ac_buffer builder
00355  */
00356 static inline size_t ac_buffer_builder_writable(ac_buffer_builder_t *pBuilder)
00357 {
00358     return ac_buffer_builder_space(pBuilder);
00359 }
00360 
00361 #ifdef __cplusplus
00362 }
00363 #endif
00364 
00365 #endif /* ACORE_BUFFER_BUILDER_H_ */
00366 
00367 /**
00368  * @}
00369  * @}
00370  * */