crypt/record.h

Go to the documentation of this file.

// -*- c++ -*-
//
// $Id: record.h 3342 2010-09-17 18:32:00Z java $
//
// Copyright (C) 2008-2010  Rafael Ostertag
//
// This file is part of YAPET.
//
// YAPET is free software: you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later
// version.
//
// YAPET 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.  See the GNU General Public License for more
// details.
//
// You should have received a copy of the GNU General Public License along with
// YAPET.  If not, see <http://www.gnu.org/licenses/>.
//
// Additional permission under GNU GPL version 3 section 7
//
// If you modify this program, or any covered work, by linking or combining it
// with the OpenSSL project's OpenSSL library (or a modified version of that
// library), containing parts covered by the terms of the OpenSSL or SSLeay
// licenses, Rafael Ostertag grants you additional permission to convey the
// resulting work.  Corresponding Source for a non-source form of such a
// combination shall include the source code for the parts of OpenSSL used as
// well as that of the covered work.
//

#ifndef _RECORD_H
#define _RECORD_H

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#ifdef HAVE_INTTYPES_H
# include <inttypes.h>
#endif

#ifdef HAVE_STDLIB_H
# include <stdlib.h>
#endif

#ifdef HAVE_STRING_H
# include <string.h>
#endif

#include "../intl.h"

#include "bdbuffer.h"
#include "yapetexception.h"

namespace YAPET {

    template<class T>
    class Record {
        private:
            uint32_t _size;
            T* data;

            void alloc_mem() throw (YAPETException) {
                data = (T*) malloc (sizeof (T) );

                if (data == NULL)
                    throw YAPETException (_ ("Memory exhausted") );

                _size = sizeof (T);
            }

            void free_mem() {
                memset (data, 0, _size);
                free (data);
            }

        public:
            Record<T> (const T& d) throw (YAPETException) {
                alloc_mem();
                memcpy (data, &d, sizeof (T) );
            }

            Record<T>() throw (YAPETException) {
                alloc_mem();
            }

            Record<T> (const Record<T>& r) throw (YAPETException) {
                alloc_mem();
                memcpy (data, r.data, _size);
            }

            virtual ~Record<T>() {
                free_mem();
            }

            uint32_t size() const {
                return _size;
            }

            T* getData() {
                return data;
            }
            const T* getData() const {
                return data;
            }

            operator T*() {
                return data;
            }
            operator const T*() const {
                return data;
            }
            operator uint8_t*() {
                return (uint8_t*) data;
            }
            operator const uint8_t*() const {
                return (const uint8_t*) data;
            }

            const Record<T>& operator= (const Record<T>& r)
            throw (YAPETException) {
                if (this == &r) return *this;

                free_mem();
                // This sets _size member too
                alloc_mem();
                memcpy (data, r.data, r._size);
                return *this;
            }

            const Record<T>& operator= (const T& r) throw (YAPETException) {
                free_mem();
                // This sets _size member too
                alloc_mem();
                memcpy (data, &r, _size);
                return *this;
            }

            const Record<T>& operator= (const T* r) throw (YAPETException) {
                free_mem();
                // This sets _size member too
                alloc_mem();
                memcpy (data, r, _size);
                return *this;
            }

            const Record<T>& operator= (const BDBuffer& bdb)
            throw (YAPETException) {
        // As of version 0.6, the exnum is used to determine whether to use a 32 or 64 bit header
                if (bdb.size() < _size)
                    throw YAPETException (_ ("BDBuffer too small. Cannot assign to Record<T>"), BDBUFFER_TOO_SMALL );
        if (bdb.size() > _size)
            throw YAPETException (_ ("BDBuffer too big. Cannot assign to Record<T>"), BDBUFFER_TOO_BIG );

                free_mem();
                // This sets _size member too
                alloc_mem();
                memcpy (data, bdb(), _size);
                return *this;
            }
    };
}

#endif // _RECORD_H