cmemory.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef CMEMORY_H
#define CMEMORY_H 1

#include <set>
#include <string>
#include <sstream>
#include <inttypes.h>
#include <pthread.h>
#include <stdlib.h>

#include "croflexception.h"
#include "logging.h"

namespace rofl
{

/* error classes */
class eMemBase                          : public RoflException {};
class eMemAllocFailed           : public eMemBase {};
class eMemOutOfRange            : public eMemBase {};
class eMemNotFound                      : public eMemBase {};
class eMemInval                         : public eMemBase {};



class cmemory {
private:

        static std::set<cmemory*>               cmemory_list;
        static pthread_mutex_t                  memlock;
        static int                                              memlockcnt;

        std::pair<uint8_t*, size_t>     data;           //< memory area including head- and tail-space

#define CMEMORY_DEFAULT_SIZE            0


public:



        cmemory(
                        size_t len = CMEMORY_DEFAULT_SIZE);



        cmemory(
                        uint8_t *data,
                        size_t datalen);



        cmemory(
                        cmemory const& m);



        virtual
        ~cmemory();


public:

        cmemory&
        operator= (
                        cmemory const& m);



        uint8_t&
        operator[] (
                        size_t index) const;



        bool
        operator== (
                        cmemory const& m) const;



        bool
        operator!= (
                        cmemory const& m) const;



        bool
        operator< (
                        cmemory const& m) const;


        bool
        operator> (
                        cmemory const& m) const;



        cmemory
        operator& (
                        cmemory const& m) const;



        cmemory&
        operator+= (
                        cmemory const& m);



        cmemory
        operator+ (
                        cmemory const& m);



        uint8_t*
        somem() const;



        size_t
        memlen() const;



        virtual void
        assign(
                        uint8_t *buf,
                        size_t buflen);



        virtual size_t
        length() const { return data.second; };



        virtual uint8_t*
        resize(
                        size_t len);



        uint8_t*
        insert(
                        uint8_t *ptr,
                        size_t len);


        uint8_t*
        insert(
                        unsigned int offset,
                        size_t len);



        void
        remove(
                        uint8_t *ptr,
                        size_t len);



        void
        remove(
                        unsigned int offset,
                        size_t len);



        unsigned int
        find_first_of(
                        uint8_t value,
                        unsigned int start);



        void
        clear();



        virtual void
        pack(
                        uint8_t *buf,
                        size_t buflen);



        virtual void
        unpack(
                        uint8_t *buf,
                        size_t buflen);


        virtual std::string
        toString() const;


        virtual bool
        empty() const { return (0 == memlen()); };

private: // methods


        void
        mallocate(
                        size_t len) throw (eMemAllocFailed);


        void mfree();

public:

        friend std::ostream&
        operator<< (std::ostream& os, cmemory const& mem) {
                os << indent(0) << "<cmemory: ";
                os << "data:" << (void*)mem.data.first << " ";
                os << "datalen:" << (int)mem.data.second << " ";
                os << ">" << std::endl;

                unsigned int const width = 32;

                if (mem.data.second > 0) {
                        for (unsigned int i=0; i < mem.data.second; i++) {
                                if (0 == (i % width)) {
                                        os << indent(2)
                                                << std::setfill('0')
                                                << std::setw(4)
                                                << std::dec << (i/width) << ": " << std::hex
                                                << std::setw(0)
                                                << std::setfill(' ');
                                }

                                os << std::setfill('0')
                                        << std::setw(2)
                                        << std::hex << (int)(*(mem.somem() + i)) << std::dec
                                        << std::setw(0)
                                        << std::setfill(' ')
                                        << " ";

                                if (0 == ((i+1) % 8))
                                        os << "  ";
                                if (0 == ((i+1) % width))
                                        os << std::endl;
                        }
                        os << std::endl;
                }
                return os;
        };
};

}; // end of namespace

#endif