acedia/acedia_util.hpp

/*                                                                            *\
**                          Copyright (C) 2009-2010                           **
**       Dominik Charousset < Dominik.Charousset (at) haw-hamburg.de >        **
**                                                                            **
**            MMM       MMMMMM   MMMMMMMMM MMMMMMM   MMM       MMM            **
**           MMMMM     MMMMMMMM  MMMMMMMMM MMMMMMMM  MMM      MMMMM           **
**          MMM MMM   MMM        MMMM      MMM   MMM MMM     MMM MMM          **
**         MMM   MMM  MMM        MMMMMMMMM MMM   MMM MMM    MMM   MMM         **
**        MMMMMMMMMMM MMMM   MMM MMMM      MMM   MMM MMM   MMMMMMMMMMM        **
**       MMM       MMM MMMMMMMM  MMMMMMMMM MMMMMMMM  MMM  MMM       MMM       **
**      MMM         MMM MMMMMM   MMMMMMMMM MMMMMMM   MMM MMM         MMM      **
**                                                                            **
**                                                                            **
** This file is part of the acedia library.                                   **
**                                                                            **
** This library is free software: you can redistribute it and/or modify       **
** it under the terms of the GNU Lesser General Public License as published   **
** by the Free Software Foundation, either version 3 of the License, or       **
** (at your option) any later version.                                        **
**                                                                            **
** This library 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 Lesser General Public License for more details.                        **
**                                                                            **
** You should have received a copy of the GNU Lesser General Public License   **
** along with acedia. If not, see <http://www.gnu.org/licenses/>.             **
\*                                                                            */

#ifndef ACEDIA_UTIL_H
#define ACEDIA_UTIL_H

#include "acedia_config.hpp"

#ifdef ACEDIA_WINDOWS
#include <Winsock2.h>
#include <Windows.h>
#else
#include <netinet/in.h>
#endif

#include <list>
#include <limits>
#include <vector>
#include <sstream>

#include "unit.hpp"
#include "acedia_config.hpp"
#include "acedia_atomic.hpp"
#include "acedia_string.hpp"
#include "acedia_preprocessor.hpp"

#include <boost/cstdint.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/static_assert.hpp>
#include <boost/thread/condition_variable.hpp>

#ifdef ACEDIA_WINDOWS
#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
typedef int ssize_t;
#pragma comment(lib, "wininet.lib")
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#endif

namespace acedia
{
    static const ::ssize_t ui32Size = (::ssize_t) sizeof(boost::uint32_t);

#   ifdef ACEDIA_WINDOWS
        typedef SOCKET NativeSocketType;
        typedef const char* SocketSendPtr;
        typedef char* SocketRecvPtr;
#   else
        typedef int NativeSocketType;
        typedef const void* SocketSendPtr;
        typedef void* SocketRecvPtr;
        inline void closesocket(NativeSocketType s) { close(s); }
#   endif

    namespace details
    {
        class AnyArrayProcessor; // forward declaration
        struct SocketIOStreamPrivate; // forward declaration

        template<class NativeContainer>
        class SharedContainerImpl : public NativeContainer
        {

            volatile boost::int32_t m_rc; // reference count

         public:

            using NativeContainer::const_iterator;

            inline SharedContainerImpl() : NativeContainer(), m_rc(1) { }

            inline void ref() { (void) atomic::addAndFetch(&m_rc, 1); }
            inline bool deref() { return 0 != atomic::addAndFetch(&m_rc, -1); }
            inline bool unique() const { return 1 == m_rc; }

            inline SharedContainerImpl* deep_copy() const
            {
                SharedContainerImpl* copy = new SharedContainerImpl;
                copy->insert(copy->begin(), this->begin(), this->end());
                return copy;
            }

            inline bool operator==(const SharedContainerImpl& other)
            {
                return ((NativeContainer&) *this) == ((const NativeContainer&) other);
            }

        };

    }
}

namespace acedia
{

    static const boost::int32_t Int32Minimum = 0x80000000;
    static const boost::uint32_t UInt32Maximum = 0xFFFFFFFF;

    namespace util
    {

        // Derive this class to prohibit objects of a class
        class no_instances
        {
            no_instances();
        };

        template<typename T, class ListImpl, class IteratorImpl>
        class ContainerIterator
        {

            ListImpl* list;
            IteratorImpl nativeIterator;

         public:

            ContainerIterator(ListImpl* nl, IteratorImpl ni) :
                    list(nl),
                    nativeIterator(ni)
            {
                nl->ref();
            }

            ContainerIterator(const ContainerIterator& other) :
                    list(other.list),
                    nativeIterator(other.nativeIterator)
            {
                other.list->ref();
            }

            ~ContainerIterator()
            {
                if (!list->deref()) delete list;
            }

            const T& operator*() { return *nativeIterator; }

            const T* operator->() { return &(*nativeIterator); }

            ContainerIterator& operator++()
            {
                ++nativeIterator;
                return *this;
            }

            ContainerIterator operator++(int)
            {
                ContainerIterator tmp(*this);
                ++(*this);
                return tmp;
            }

            ContainerIterator& operator--()
            {
                --nativeIterator;
                return *this;
            }

            ContainerIterator operator--(int)
            {
                ContainerIterator tmp(*this);
                --(*this);
                return tmp;
            }

            ContainerIterator& operator=(const ContainerIterator& other)
            {
                if (!list->deref()) delete list;
                other.list->ref();
                list = other.list;
                nativeIterator = other.nativeIterator;
                return *this;
            }

            bool operator==(const ContainerIterator& other)
            {
                return list == other.list
                        && nativeIterator == other.nativeIterator;
            }

            bool operator!=(const ContainerIterator& other)
            {
                return !((*this) == other);
            }

        };

        template<typename T, class SharedContainer>
        class Container
        {

         protected:

            SharedContainer* d;

            void detach()
            {
                if (!d->unique())
                {
                    SharedContainer* nd = d->deep_copy();
                    if (!d->deref()) delete d;
                    d = nd;
                }
            }

         public:

            typedef ContainerIterator<T, SharedContainer, typename SharedContainer::const_iterator> ConstIterator;

            Container() : d(new SharedContainer) { }

            Container(const Container& other) : d(other.d) { other.d->ref(); }

            virtual ~Container() { if (!d->deref()) delete d; }

            ::size_t size() const { return d->size(); }

            Container& append(const T& element)
            {
                detach();
                d->push_back(element);
                return *this;
            }

            ConstIterator begin() const
            {
                return ConstIterator(d, d->begin());
            }

            ConstIterator end() const
            {
                return ConstIterator(d, d->end());
            }

            bool operator==(const Container& other) const
            {
                if (d == other.d) return true;
                else return (*d) == (*other.d);
            }

            void serialize(boost::archive::text_oarchive &ar,
                           const unsigned int) const
            {
                boost::uint32_t s = size();
                ar << s;
                for (ConstIterator i = this->begin(); i != this->end(); ++i)
                {
                    ar << (*i);
                }
            }

            void serialize(boost::archive::text_iarchive &ar,
                           const unsigned int)
            {
                detach();
                boost::uint32_t s;
                ar >> s;
                for (boost::uint32_t i = 0; i < s; ++i)
                {
                    T element;
                    ar >> element;
                    append(element);
                }
            }

        };

        template<typename T>
        class List : public Container< T, details::SharedContainerImpl< std::list<T> > >
        {

            typedef Container< T, details::SharedContainerImpl< std::list<T> > > ListBase;

         public:

            List() { }
            List(const T& firstElement) { append(firstElement); }
            List(const List& other) : ListBase(other) { }

        };

        template<typename T>
        class Vector : public Container< T, details::SharedContainerImpl< std::vector<T> > >
        {

            typedef Container< T, details::SharedContainerImpl< std::vector<T> > > VectorBase;

         public:

            Vector() { }
            Vector(const T& firstElement) { append(firstElement); }
            Vector(const Vector& other) : VectorBase(other) {  }

            const T& operator[](::size_t i) const { return (*(this->d))[i]; }

        };

        class Semaphore
        {

            volatile boost::int32_t m_value;
            boost::mutex m_mutex;
            boost::condition_variable m_condition;

        public:

            inline Semaphore(boost::int32_t initValue = 0) throw() :
                    m_value(initValue)
            {
            }

            void release(boost::int32_t n = 1);

            void acquire(boost::int32_t n = 1);

            bool tryAcquire(boost::int32_t n = 1);

            bool tryAcquire(boost::int32_t n, boost::uint16_t msTimeout);

            inline int available () const throw() { return m_value; }

        };

        class Spinlock
        {

            volatile boost::int32_t m_value;

        public:

            inline Spinlock() throw() : m_value(0) { }

            void lock() throw();

            inline void unlock() throw()
            {
                // make sure there is no pending memory access and
                // told both compiler and cpu to not reorder the CAS operation
                // around this barrier
                ACEDIA_MEMORY_BARRIER();
                assert(atomic::compareAndSwap(&m_value, 1, 0));
            }

        };

        class SpinlockGuard
        {

            Spinlock &slock;

        public:

            // performs slock.lock();
            SpinlockGuard(Spinlock &spinlock);

            // performs slock.unlock();
            ~SpinlockGuard();
        };

        class RWSpinlock
        {

            volatile boost::int32_t m_value;

        public:

            inline RWSpinlock() throw() : m_value(0) { }

            void sharedLock();

            inline void sharedUnlock()
            {
                ACEDIA_MEMORY_BARRIER();
                (void) atomic::addAndFetch(&m_value, -1);
            }

            void exclusiveLock();

            inline void exclusiveUnlock()
            {
                ACEDIA_MEMORY_BARRIER();
                assert(atomic::compareAndSwap(&m_value, Int32Minimum, 0));
            }

        };

        class SharedLockGuard
        {
            RWSpinlock &rwlock;
        public:
            SharedLockGuard(RWSpinlock &rwlock);
            ~SharedLockGuard();
        };

        class ExclusiveLockGuard
        {
            RWSpinlock &rwlock;
        public:
            ExclusiveLockGuard(RWSpinlock &rwlock);
            ~ExclusiveLockGuard();
        };

        String eraseWhitespaces(const char *input);


        /**********************************************************************
         *                             IfElseType                             *
         **********************************************************************/

        template<int VAL, typename T1, typename T2>
        struct IfElseType { typedef T1 type; };

        template<typename T1, typename T2>
        struct IfElseType<0,T1,T2> { typedef T2 type; };


        /**********************************************************************
         *                              ResultOf                              *
         **********************************************************************/

        template<int N, ACEDIA_DEF_WITH_DEFAULT_T1_TO_T10() >
        struct ResultOf {};

        template<ACEDIA_DEF_T1_TO_T10()>
        struct ResultOf<0,ACEDIA_GET_T1_TO_T10()> { typedef T1 type; };

        template<ACEDIA_DEF_T1_TO_T10()>
        struct ResultOf<1,ACEDIA_GET_T1_TO_T10()> { typedef T2 type; };

        template<ACEDIA_DEF_T1_TO_T10()>
        struct ResultOf<2,ACEDIA_GET_T1_TO_T10()> { typedef T3 type; };

        template<ACEDIA_DEF_T1_TO_T10()>
        struct ResultOf<3,ACEDIA_GET_T1_TO_T10()> { typedef T4 type; };

        template<ACEDIA_DEF_T1_TO_T10()>
        struct ResultOf<4,ACEDIA_GET_T1_TO_T10()> { typedef T5 type; };

        template<ACEDIA_DEF_T1_TO_T10()>
        struct ResultOf<5,ACEDIA_GET_T1_TO_T10()> { typedef T6 type; };

        template<ACEDIA_DEF_T1_TO_T10()>
        struct ResultOf<6,ACEDIA_GET_T1_TO_T10()> { typedef T7 type; };

        template<ACEDIA_DEF_T1_TO_T10()>
        struct ResultOf<7,ACEDIA_GET_T1_TO_T10()> { typedef T8 type; };

        template<ACEDIA_DEF_T1_TO_T10()>
        struct ResultOf<8,ACEDIA_GET_T1_TO_T10()> { typedef T9 type; };

        template<ACEDIA_DEF_T1_TO_T10()>
        struct ResultOf<9,ACEDIA_GET_T1_TO_T10()> { typedef T10 type; };

        /**********************************************************************
         *                             UnboxUtil                              *
         **********************************************************************/
        template<class C>
        struct UnboxUtil
        {
            typedef Unit UnboxedRuleBuilder;
            static UnboxedRuleBuilder doUnbox(details::AnyArrayProcessor*)
            {
                return Unit();
            }
        };

        /**********************************************************************
         *                               IsUnit                               *
         **********************************************************************/
        template<class T> struct IsUnit { enum { VALUE = 0 }; };
        template<> struct IsUnit<Unit> { enum { VALUE = 1 }; };

        /**********************************************************************
         *                            IsCaseClass                             *
         **********************************************************************/
        /*
         * @brief This 'annotation' marks classes that don't have any
         *        data fields.
         */
        template<class T> struct IsCaseClass { enum { VALUE = 0 }; };
        template<> struct IsCaseClass<Unit> { enum { VALUE = 1 }; };

        /**********************************************************************
         *                         string conversion                          *
         **********************************************************************/
        /*
         * @brief This 'annotation' marks data types that have a built in
         *        conversion to strings such as boost::int32_t etc.
         */
        template<typename T> struct HasBuiltInToString{enum{VALUE = 0};};
        template<> struct HasBuiltInToString<float>{enum{VALUE = 1};};
        template<> struct HasBuiltInToString<double>{enum{VALUE = 1};};
        template<> struct HasBuiltInToString<boost::int8_t>{enum{VALUE = 1};};
        template<> struct HasBuiltInToString<boost::uint8_t>{enum{VALUE = 1};};
        template<> struct HasBuiltInToString<boost::int16_t>{enum{VALUE = 1};};
        template<> struct HasBuiltInToString<boost::uint16_t>{enum{VALUE = 1};};
        template<> struct HasBuiltInToString<boost::int32_t>{enum{VALUE = 1};};
        template<> struct HasBuiltInToString<boost::uint32_t>{enum{VALUE = 1};};
        template<> struct HasBuiltInToString<boost::int64_t>{enum{VALUE = 1};};
        template<> struct HasBuiltInToString<boost::uint64_t>{enum{VALUE = 1};};
        template<> struct HasBuiltInToString<std::string>{enum{VALUE = 1};};
        /*
         * @brief This template uses the built in string conversion of
         *        std::ostringstream if available.
         */
        template<int N, typename T>
        struct BuiltInToString
        {
            inline static void appendTo(std::ostringstream &stream, const T &)
            {
                stream << "-?-";
            }
        };
        template<typename T>
        struct BuiltInToString<1, T>
        {
            inline static void appendTo(std::ostringstream &stream, const T &what)
            {
                stream << what;
            }
        };
        /*
         * @brief This template converts any value into a string. The default
         *        implementation can convert only types that are annotatet
         *        with IsUnit or has a built in conversion.
         *
         * Provide a specialization of this template if you want to add
         * string conversion from your custom type by
         * {@link acedia::Message Message}.
         */
        template<typename T>
        struct AsString
        {
            static String get(const T& what)
            {
                if (HasBuiltInToString<T>::VALUE)
                {
                    std::ostringstream out;
                    BuiltInToString<HasBuiltInToString<T>::VALUE,T>
                    ::appendTo(out, what);
                    return out.str();
                }
                else return "-?-";
                /*
                MetaClass *mc = details::MetaClassImpl<T>::instace();
                std::ostringstream out(mc->name());
                if (IsCaseClass<T>::VALUE)
                {
                    out << "()";
                }
                else
                {
                    BuiltInToString<HasBuiltInToString<T>::VALUE
                            , T>::appendTo(out, what);
                }
                return out.str();
                */
            }
        };
        // this specialisation provides a 'nice' conversion from booleans
        template<>
        struct AsString<bool>
        {
            inline static String get(bool value)
            {
                return value ? "true" : "false";
            }
        };
        // specialisation for acedia::String
        template<>
        struct AsString<String>
        {
            inline static String get(const String& value)
            {
                return value;
            }
        };

        /**********************************************************************
         *                           serialization                            *
         **********************************************************************/
        template<typename T> struct IsIntegerType {enum{VALUE = 0};};
        template<> struct IsIntegerType<boost::int8_t>{enum{VALUE = 1};};
        template<> struct IsIntegerType<boost::uint8_t>{enum{VALUE = 1};};
        template<> struct IsIntegerType<boost::int16_t>{enum{VALUE = 1};};
        template<> struct IsIntegerType<boost::uint16_t>{enum{VALUE = 1};};
        template<> struct IsIntegerType<boost::int32_t>{enum{VALUE = 1};};
        template<> struct IsIntegerType<boost::uint32_t>{enum{VALUE = 1};};
        template<> struct IsIntegerType<boost::int64_t>{enum{VALUE = 1};};
        template<> struct IsIntegerType<boost::uint64_t>{enum{VALUE = 1};};

        template<int X, typename T>
        struct SingletonAccess
        {
            inline static T get() { throw 666; }
        };

        template<typename T>
        struct SingletonAccess<1, T>
        {
            inline static T get() { return T::instance(); }
        };

        /*
        template<typename T>
        struct Deserializer
        {
            static T deserializeFrom(void* from, int &readedBytes)
            {
                readedBytes = 0;
            }
        };

        template<>
        struct Deserializer<String>
        {
            static String deserializeFrom(void *from, int &readedBytes)
            {
                readedBytes = 0;
                boost::uint32_t *ssize = (boost::uint32_t*) from;
                boost::uint32_t size = ntohl(*ssize);
                readedBytes += sizeof(boost::uint32_t);
                readedBytes += size;
                if ((reinterpret_cast<const char*>(from))[size] != '\0')
                {
                    ACEDIA_THROW(NotDeserializableException,
                                 "String not null-terminated");
                }
                else
                {
                    return String(reinterpret_cast<const char*>(from)
                                  + sizeof(boost::uint32_t));
                }
            }
        };
        */

        /**********************************************************************
         *                             singleton                              *
         **********************************************************************/
        template<class C>
        class Singleton
        {

            volatile C* m_instance;
            Spinlock m_lock;

         public:

            Singleton() : m_instance(NULL) { }

            C* instance()
            {
                C* tmp = const_cast<C*>(m_instance);
                ACEDIA_MEMORY_BARRIER();
                if (NULL == tmp)
                {
                    SpinlockGuard guard(m_lock);
                    // check condition again (Double-Checked Locking Pattern)
                    tmp = const_cast<C*>(m_instance);
                    if (NULL == tmp)
                    {
                        tmp = new C;
                        // This DCLP-implementation uses memory barriers
                        // to prevent Instruction Ordering.
                        // See "C++ and the Perils of Double-Checked Locking"
                        ACEDIA_MEMORY_BARRIER();
                        m_instance = tmp;
                    }
                }
                return tmp;
            }

        };

        /**********************************************************************
         *               utility classes to simplify network IO               *
         **********************************************************************/
        class EndianConverter
        {

            typedef boost::int64_t (*Int64Fun)(boost::int64_t);

            Int64Fun m_int64Fun;
            EndianConverter(const EndianConverter& other);
            EndianConverter& operator=(const EndianConverter& other);

         public:

            EndianConverter();

            inline boost::int8_t operator()(boost::int8_t i) const { return i; }

            inline boost::int16_t operator()(boost::int16_t i) const
            {
                return htons(i);
            }

            inline boost::int32_t operator()(boost::int32_t i) const
            {
                return htonl(i);
            }

            inline boost::int64_t operator()(boost::int64_t i) const
            {
                return m_int64Fun(i);
            }

            inline boost::uint8_t operator()(boost::uint8_t i) const {return i;}

            inline boost::uint16_t operator()(boost::uint16_t i) const
            {
                return htons(i);
            }

            inline boost::uint32_t operator()(boost::uint32_t i) const
            {
                return htonl(i);
            }

            inline boost::uint64_t operator()(boost::uint64_t i) const
            {
                return (boost::uint64_t) m_int64Fun((boost::int64_t) i);
            }

        };

        struct AbstractEndianAwareStream
        {
            virtual ~AbstractEndianAwareStream();
            const acedia::util::EndianConverter convert;
        };

        struct EndianAwareInputStream : public virtual AbstractEndianAwareStream
        {
            virtual void read(char* buffer, ::size_t numBytes) = 0;

            template<typename T>
            void readInt(T& value)
            {
                BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_integer);
                read((char*) &value, sizeof(T));
                value = convert(value);
            }
        };

        struct EndianAwareOutputStream: public virtual AbstractEndianAwareStream
        {
            virtual void write(const char* buffer, ::size_t numBytes) = 0;

            template<typename T>
            void writeInt(const T& value)
            {
                BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_integer);
                T tmp = convert(value);
                write((const char*) &tmp, sizeof(T));
            }
        };

        struct EndianAwareStream : public EndianAwareInputStream
                                 , public EndianAwareOutputStream
        {
        };

        inline EndianAwareOutputStream& operator<<(EndianAwareOutputStream& s,
                                                   boost::int8_t value)
        {
            s.writeInt(value);
            return s;
        }

        inline EndianAwareOutputStream& operator<<(EndianAwareOutputStream& s,
                                                   boost::int16_t value)
        {
            s.writeInt(value);
            return s;
        }

        inline EndianAwareOutputStream& operator<<(EndianAwareOutputStream& s,
                                                   boost::int32_t value)
        {
            s.writeInt(value);
            return s;
        }

        inline EndianAwareOutputStream& operator<<(EndianAwareOutputStream& s,
                                                   boost::int64_t value)
        {
            s.writeInt(value);
            return s;
        }

        inline EndianAwareOutputStream& operator<<(EndianAwareOutputStream& s,
                                                   boost::uint8_t value)
        {
            s.writeInt(value);
            return s;
        }

        inline EndianAwareOutputStream& operator<<(EndianAwareOutputStream& s,
                                                   boost::uint16_t value)
        {
            s.writeInt(value);
            return s;
        }

        inline EndianAwareOutputStream& operator<<(EndianAwareOutputStream& s,
                                                   boost::uint32_t value)
        {
            s.writeInt(value);
            return s;
        }

        inline EndianAwareOutputStream& operator<<(EndianAwareOutputStream& s,
                                                   boost::uint64_t value)
        {
            s.writeInt(value);
            return s;
        }

        EndianAwareOutputStream& operator<<(EndianAwareOutputStream& s,
                                            const std::string& str);

        inline EndianAwareOutputStream& operator<<(EndianAwareOutputStream& s,
                                                   const acedia::String& str)
        {
            s << (str.const_str());
            return s;
        }

        inline void operator>>(EndianAwareInputStream& s, boost::int8_t& value)
        {
            s.readInt(value);
        }

        inline void operator>>(EndianAwareInputStream& s, boost::int16_t& value)
        {
            s.readInt(value);
        }

        inline void operator>>(EndianAwareInputStream& s, boost::int32_t& value)
        {
            s.readInt(value);
        }

        inline void operator>>(EndianAwareInputStream& s, boost::int64_t& value)
        {
            s.readInt(value);
        }

        inline void operator>>(EndianAwareInputStream& s, boost::uint8_t& value)
        {
            s.readInt(value);
        }

        inline void operator>>(EndianAwareInputStream& s, boost::uint16_t& val)
        {
            s.readInt(val);
        }

        inline void operator>>(EndianAwareInputStream& s, boost::uint32_t& val)
        {
            s.readInt(val);
        }

        inline void operator>>(EndianAwareInputStream& s, boost::uint64_t& val)
        {
            s.readInt(val);
        }

        void operator>>(EndianAwareInputStream& s, acedia::String& str);

        void operator>>(EndianAwareInputStream& s, std::string& str);

        class SocketIOStream : public EndianAwareStream
        {

            details::SocketIOStreamPrivate* d;
            SocketIOStream& operator=(const SocketIOStream& other);

         public:

            SocketIOStream(NativeSocketType socketDescriptor);

            SocketIOStream(const SocketIOStream& other);

            void close();

            ~SocketIOStream();

            void readStringToBuffer();

            const char* buffer();

            void write /*[[override]]*/ (const char* what, ::size_t size);

            void read /*[[override]]*/ (char* what, ::size_t size);

            void readToBuffer(::size_t size);

        };

    }
}



#endif // ACEDIA_UTIL_H

---