libnebular-extra.templates.hpp

Go to the documentation of this file.

#include "config.h"
#include "libnebular.hpp"
#include "libnebular-plugin.hpp"

#include <sstream>

#ifndef LIBNEBULAR_EXTRA_TEMPLATES_HPP_
#define LIBNEBULAR_EXTRA_TEMPLATES_HPP_

#if HAVE_BOOST_LEXICAL_CAST_HPP
#include <boost/lexical_cast.hpp>
#endif

namespace libnebular{
    #if HAVE_BOOST_LEXICAL_CAST_HPP

    template <typename Src> String PicturePropContainer::castToPropString(const Src &value){
        try{
            String result = boost::lexical_cast<String>(value);
            return result;
        }catch(boost::bad_lexical_cast &){
            throw LIBNEBULAR_ERROR("Cannot convert from requested type to property string");
        }
    }

    template <typename Dest> Dest PicturePropContainer::castFromPropString(const String &value){
        try{
            if(
                boost::is_integral<Dest>::value
            ){
                const String hexPrefix = "0x";
                if( value.substr(0, hexPrefix.length()) == hexPrefix ){
                    std::istringstream streamFromArg(value.substr( hexPrefix.length() ));
                    Dest result;
                    streamFromArg >> std::hex >> result;
                    return result;
                }
            }

            Dest result = boost::lexical_cast<Dest>(value);
            return result;
        }catch(boost::bad_lexical_cast &){
            throw LIBNEBULAR_ERROR(String() + "Cannot convert from property string \"" +
            value + "\" to requested type");
        }
    }

#endif // HAVE_BOOST_LEXICAL_CAST_HPP


    namespace bits{
        template <typename BitContainer>
        Integer getContigLength(BitContainer a){
            if(a < 0){
                throw LIBNEBULAR_ERROR("Bit mask shouldn't be negative");
            }

            while( a != 0 && ((a & 1) == 0) ){
                a >>= 1;
            }

            Integer length = 0;
            while( ((a & 1) != 0) ){
                a >>= 1;
                ++length;
            }

            if(a != 0){
                return ARE_NOT_CONTIG;
            }

            return length;
        }

        template <typename BitContainer>
        Integer getHighestBitIndex(BitContainer a){
            Integer highestBitIndex = -1;
            if(a < 0){
                throw LIBNEBULAR_ERROR("Bit mask shouldn't be negative");
            }

            while( a != 0 ){
                a >>= 1;
                ++highestBitIndex;
            }

            if(highestBitIndex == -1){
                return HAVE_NOT;
            }

            return highestBitIndex;
        }


        template <typename BitContainer>
        bool areContig(BitContainer a){
            return getContigLength(a) != ARE_NOT_CONTIG;
        }

        template <typename BitContainer>
        bool areSubsetOf(BitContainer a, BitContainer b){
            return (~a & b) == 0;
        }

        template <typename BitContainer>
        BitContainer generateContig(Integer length){
            BitContainer bits = 0;
            for(Integer idxBit = 0; idxBit < length; ++idxBit){
                bits <<= 1;
                ++bits;
            }
            return bits;
        }
    }

}

#endif // LIBNEBULAR_EXTRA_TEMPLATES_HPP_

---