Форум 'Исходники' на RSDN

Генерация динамической превью для демонстрации картинки

Tue, 17 Feb 2026 13:00:15 GMT

<?php
// big2small.php
if(isset($_GET['pixmap']))$pixmap=$_GET['pixmap'];
else exit();
/* echo $pixmap."<br>";
exit(); */
list($w0,$h0,$type,$attr)=getimagesize($pixmap);
/* echo "<img src="$pixmap" $attr></img>";
exit(); */

$w=200;// Размер трекера и ширина превью.
$rt=$w/$w0;// Коэффициент для пересчёта высоты превью.

switch($type){
case IMAGETYPE_JPEG:
        $img=imagecreatefromjpeg($pixmap);
        break;
case IMAGETYPE_GIF:
        $img=imagecreatefromgif($pixmap);
        break;
case IMAGETYPE_PNG:
        $img=imagecreatefrompng($pixmap);
        break;
default:exit();}
if($rt<1){// Картинка не поместится в трекер:
        // 1) перерисовываем с сохранением пропорций,
        $h=round($h0*$rt);// высоту надо округлить до целого;
        $img0=imagecreatetruecolor($w,$h);
        imagecopyresized($img0,$img,0,0,0,0,$w,$h,$w0,$h0);
        // 2) показываем превью.
        switch($type){
        case IMAGETYPE_JPEG:
                Header("Content-type: image/jpeg");
                imagejpeg($img0);
                break;
        case IMAGETYPE_GIF:
                Header("Content-type: image/gif");
                imagegif($img0);
                break;
        case IMAGETYPE_PNG:
                Header("Content-type: image/png");
                imagepng($img0);
                break;
        default:exit();}}
else{// Картинка поместится в трекер:
        // ничего не делаем, показываем оригинал.
        switch($type){
        case IMAGETYPE_JPEG:
                Header("Content-type: image/jpeg");
                imagejpeg($img);
                break;
        case IMAGETYPE_GIF:
                Header("Content-type: image/gif");
                imagegif($img);
                break;
        case IMAGETYPE_PNG:
                Header("Content-type: image/png");
                imagepng($img);
                break;
        default:exit();}}
imagedestroy($img);
imagedestroy($img0);
?>

Использовать:

<img src="http://192.168.24.80:8080/tuxoid/big2small.php?pixmap=http://i56.tinypic.com/28211yx.png" border="0"></img>

Нужна GD.

Decimal for C++

Sun, 27 Dec 2020 14:58:18 GMT

Здравствуйте!

Неохота было что-то искать, накидал на скорую руку

#pragma once


#include <string>
#include <cstdint>
#include <utility>
#include <limits>
#include <iostream>
#include <exception>
#include <stdexcept>


//----------------------------------------------------------------------------
namespace marty
{



//----------------------------------------------------------------------------
// 4 294 967 295 uint32_t max
// 1 000 000 000 - must be enough for money or use more wide type in typedef below

typedef std::uint32_t  DecimalDenumeratorRawType;
typedef std::int32_t   DecimalDenumeratorSignedRawType;

//----------------------------------------------------------------------------
//  9 223 372 036 854 775 808
//  1 000 000 000.000 000  000 - 10**9 -  миллиард - бюджет страны верстать не выйдет с точностью 9 нулей после точки
//  1 000 000 000 000 00.0 000 - 10**15 - 100 трлн с точностью до сотых копейки - для домашней бухгалтерии норм

typedef std::int64_t   DecimalNumeratorRawType;



//----------------------------------------------------------------------------
class DecimalDenumerator;

class DecimalPrecision
{
    friend class DecimalDenumerator;

    std::uint32_t m_precision;

    // default constructor disabled
    DecimalPrecision( );
    //DecimalPrecision& operator=( const DecimalPrecision &dp );

public:

    typedef std::uint32_t                    precision_t;
    typedef DecimalDenumeratorRawType        denum_t;
    typedef DecimalDenumeratorSignedRawType  sdenum_t;

    static denum_t denum( precision_t pr )
    {
        if ( maxPrecision<denum_t>() < pr )
            throw std::runtime_error("DecimalPrecision::denum - taken precision to big");

        return (denum_t)(getPowers10Table()[pr]);

        /*
        denum_t  denum = 1;
        for(precision_t i=0; i!=pr; ++i)
        {
            denum_t next = denum * 10u;
            if (next<denum)
                throw std::runtime_error("DecimalPrecision precision to big");
            denum = next;
        }

        return denum;
        */
    }

    DecimalPrecision( std::uint32_t pr ) : m_precision(pr) {}
    DecimalPrecision( const DecimalPrecision &pr ) : m_precision(pr.m_precision) {}

    denum_t denum( ) const
    {
        return denum(m_precision);
    }

    precision_t prec() const 
    {
        return m_precision;
    }

protected:

    template<typename IntType>
    static precision_t maxPrecision()    { throw std::runtime_error("DecimalPrecision::maxPrecision not implemented"); }

    template<> static precision_t maxPrecision<std::int32_t >() { return  9; }
    template<> static precision_t maxPrecision<std::uint32_t>() { return  9; }
    template<> static precision_t maxPrecision<std::int64_t >() { return 18; }
    template<> static precision_t maxPrecision<std::uint64_t>() { return 18; }


    static std::uint64_t* getPowers10Table()
    {
        static std::uint64_t _[] = 
        { 1                             //  0
        , 10                            //  1
        , 100                           //  2
        , 1000                          //  3
        , 10000                         //  4
        , 100000                        //  5
        , 1000000                       //  6
        , 10000000                      //  7
        , 100000000                     //  8
        , 1000000000                    //  9 - max for int32_t
        , 10000000000                   // 10
        , 100000000000                  // 11
        , 1000000000000                 // 12
        , 10000000000000                // 13
        , 100000000000000               // 14
        , 1000000000000000              // 15
        , 10000000000000000             // 16
        , 100000000000000000            // 17
        , 1000000000000000000           // 18 - max for int64_t
        };
    
        return &_[0];
    }


}; // class DecimalPrecision

//----------------------------------------------------------------------------



#define MARTY_DECIMAL_IMPLEMENT_RELATIONAL_OPERATORS( typeT2 )\
                                                              \
    bool operator<( const typeT2 v2 ) const                   \
    {                                                         \
        return compare(v2)<0;                                 \
    }                                                         \
                                                              \
    bool operator<=( const typeT2 v2 ) const                  \
    {                                                         \
        return compare(v2)<=0;                                \
    }                                                         \
                                                              \
    bool operator>( const typeT2 v2 ) const                   \
    {                                                         \
        return compare(v2)>0;                                 \
    }                                                         \
                                                              \
    bool operator>=( const typeT2 v2 ) const                  \
    {                                                         \
        return compare(v2)>=0;                                \
    }                                                         \
                                                              \
    bool operator==( const typeT2 v2 ) const                  \
    {                                                         \
        return compare(v2)==0;                                \
    }                                                         \
                                                              \
    bool operator!=( const typeT2 v2 ) const                  \
    {                                                         \
        return compare(v2)!=0;                                \
    }





//----------------------------------------------------------------------------
class Decimal;

class DecimalDenumerator
{

public:

    typedef DecimalPrecision::denum_t       denum_t    ;
    typedef DecimalPrecision::sdenum_t      sdenum_t   ;
    typedef DecimalPrecision::precision_t   precision_t;

    friend class Decimal;

    DecimalDenumerator( const DecimalPrecision dp )
    : m_precision( dp.prec() )
    , m_denum    ( dp.denum() )
    {}

    DecimalDenumerator( const DecimalDenumerator &dd )
    : m_precision( dd.m_precision )
    , m_denum    ( dd.m_denum     )
    {}

    DecimalDenumerator& operator=( const DecimalDenumerator &dd )
    {
        m_precision = dd.m_precision;
        m_denum     = dd.m_denum    ;
        return *this;
    }

    precision_t prec () const { return m_precision; }
    denum_t     denum() const { return m_denum; }

    DecimalPrecision decimalPrecision( ) const { return DecimalPrecision(m_precision); }

    void swap( DecimalDenumerator &d2 )
    {
        //using namespace std;
        std::swap( m_precision, d2.m_precision );
        std::swap( m_denum    , d2.m_denum     );
    }

    int compare( const DecimalDenumerator d2 ) const
    {
        if (m_precision<d2.m_precision) return -1;
        if (m_precision>d2.m_precision) return  1;
        return 0;
    }

    MARTY_DECIMAL_IMPLEMENT_RELATIONAL_OPERATORS(DecimalDenumerator)


protected:

    void incPrec()
    {
        tryIncDenum();
        m_precision += 1;
    }

    void decPrec()
    {
        tryDecDenum();
        m_precision -= 1;
    }

    denum_t expandTo( precision_t p )
    {
        denum_t deltaDenum = 1;
        while(m_precision < p)
        {
            incPrec();
            deltaDenum *= 10;
        }

        return deltaDenum;
    }

    denum_t shrinkTo( precision_t p )
    {
        denum_t deltaDenum = 1;
        while(m_precision > p)
        {
            decPrec();
            deltaDenum *= 10;
        }

        return deltaDenum;
    }

    sdenum_t fitTo( precision_t p )
    {
        if (m_precision<p)
            return   (sdenum_t)expandTo(p);
        else
            return - (sdenum_t)shrinkTo(p);
    }


    void tryIncDenum()
    {
        denum_t newDenum = m_denum*10u;
        if (newDenum<m_denum)
            throw std::runtime_error("DecimalDenumerator precision to big to increment");
        m_denum = newDenum;
    }

    void tryDecDenum()
    {
        if (!m_denum)
            throw std::runtime_error("DecimalDenumerator precision to small to decrement");
        m_denum = m_denum / 10u;
    }


    // default constructor disabled
    DecimalDenumerator();

    precision_t  m_precision;
    denum_t      m_denum;

}; // class DecimalDenumerator

//----------------------------------------------------------------------------




//----------------------------------------------------------------------------
inline
void swap( DecimalDenumerator &d1, DecimalDenumerator &d2 )
{
    d1.swap( d2 );
}

//----------------------------------------------------------------------------




//----------------------------------------------------------------------------
std::string toString  ( const Decimal     &d );
Decimal     fromString( const std::string &d );
void swap( Decimal &d1, Decimal &d2 );

//----------------------------------------------------------------------------




//----------------------------------------------------------------------------
class Decimal
{

    friend std::string toString  ( const Decimal     &d );
    friend Decimal     fromString( const std::string &d );
    friend void swap( Decimal &d1, Decimal &d2 );


public:

    typedef DecimalNumeratorRawType           num_t      ;
    typedef DecimalDenumerator::denum_t       denum_t    ;
    typedef DecimalDenumerator::sdenum_t      sdenum_t   ;
    typedef DecimalDenumerator::precision_t   precision_t;

    typedef DecimalDenumerator                DenumeratorType;

    Decimal()                   : m_num(0)      , m_denum(DecimalPrecision(0))   {}
    Decimal( const Decimal &d ) : m_num(d.m_num), m_denum(d.m_denum)             {}
    Decimal( int            v, const DecimalPrecision &prec = DecimalPrecision(0) ) : m_num(v), m_denum(prec) { m_num *= m_denum.denum(); }
    Decimal( unsigned       v, const DecimalPrecision &prec = DecimalPrecision(0) ) : m_num(v), m_denum(prec) { m_num *= m_denum.denum(); }
    Decimal( std::int64_t   v, const DecimalPrecision &prec = DecimalPrecision(0) ) : m_num(v), m_denum(prec) { m_num *= m_denum.denum(); }
    Decimal( std::uint64_t  v, const DecimalPrecision &prec = DecimalPrecision(0) ) : m_num(v), m_denum(prec) { m_num *= m_denum.denum(); }

    Decimal( float          f, const DecimalPrecision &prec = DecimalPrecision(0) )
    : m_num(0), m_denum(prec)
    {
        fromFloat( f, prec );
    }

    Decimal( double          f, const DecimalPrecision &prec = DecimalPrecision(0) )
    : m_num(0), m_denum(prec)
    {
        fromFloat( f, prec );
    }

    void swap( Decimal &d2 )
    {
        //using namespace std;
        std::swap( m_num   , d2.m_num   );
        m_denum.swap( d2.m_denum );
    }


    Decimal& operator=( Decimal d2 )
    {
        swap(d2);
        return *this;
    }

    // операторы преобразования типа 

    explicit operator int() const
    {
        return (int)(m_num/m_denum.denum());
    }

    explicit operator unsigned() const
    {
        return (unsigned)(m_num/m_denum.denum());
    }

    explicit operator std::int64_t() const
    {
        return (m_num/m_denum.denum());
    }

    explicit operator std::uint64_t() const
    {
        return (std::uint64_t)(m_num/m_denum.denum());
    }

    explicit operator float() const
    {
        return (float)((double)m_num/(double)m_denum.denum());
    }

    explicit operator double() const
    {
        return ((double)m_num/(double)m_denum.denum());
    }


    Decimal operator + ( Decimal d2 ) const
    {
        Decimal d1 = *this;
        adjustPrecisions( d1, d2 );
        d1.m_num += d2.m_num;
        return d1;
    }

    Decimal operator - ( Decimal d2 ) const
    {
        Decimal d1 = *this;
        adjustPrecisions( d1, d2 );
        d1.m_num -= d2.m_num;
        return d1;
    }

    Decimal operator * ( Decimal d2 ) const
    {
        num_t num = m_num * d2.m_num;

        if (m_denum < d2.m_denum)
        {
            num /= m_denum.denum();
            return Decimal( num, d2.m_denum );
        }
        else
        {
            num /= d2.m_denum.denum();
            return Decimal( num, m_denum );
        }
    }

    // 1200.00000 / 22.000 = 54.5454545454545
    // 1200 00000 / 22 000 = 5454.54545454
    Decimal operator / ( Decimal d2 ) const
    {
        d2.minimizePrecision();

        Decimal d1 = *this;
        d1.expandTo( m_denum.prec() + d2.m_denum.prec() );
        return Decimal( d1.m_num / d2.m_num, m_denum);
    }

    // 1200.00000   % 22.000    = 12.000
    // 1200         % 22        = 12
    // 1200 00000   % 22 000    = 12000
    // 1200 000000  % 22 000    = 10000
    // 1200.00000   % 22.00000  = 12.00000
    // 120000000    % 2200000   = 12 00000

    Decimal operator % ( Decimal d2 ) const
    {
        Decimal d1 = *this;
        adjustPrecisions( d1, d2 );
        d1.m_num %= d2.m_num;
        return d1;
    }


    Decimal& operator += ( Decimal d2 )
    {
        *this = operator+(d2);
        return *this;
    }

    Decimal& operator -= ( Decimal d2 )
    {
        *this = operator-(d2);
        return *this;
    }

    Decimal& operator *= ( Decimal d2 )
    {
        *this = operator*(d2);
        return *this;
    }

    Decimal& operator /= ( Decimal d2 )
    {
        *this = operator/(d2);
        return *this;
    }

    Decimal& operator %= ( Decimal d2 )
    {
        *this = operator%(d2);
        return *this;
    }

    // Decimal operator +   ( int i ) const { return operator+ ( Decimal((int)i, DecimalPrecision(0)) ); }
    // Decimal& operator += ( int i )       { return operator+=( Decimal((int)i, DecimalPrecision(0)) ); }


    #define MARTY_DECIMAL_IMPLEMENT_ARIPHMETICT_OVERLOADS_FOR_INTEGRAL_TYPE( integralType )         \
                                                                                                    \
                Decimal operator +   ( integralType i ) const { return operator+ ( Decimal(i) ); }  \
                Decimal operator -   ( integralType i ) const { return operator- ( Decimal(i) ); }  \
                Decimal operator *   ( integralType i ) const { return operator* ( Decimal(i) ); }  \
                Decimal operator /   ( integralType i ) const { return operator/ ( Decimal(i) ); }  \
                Decimal operator %   ( integralType i ) const { return operator% ( Decimal(i) ); }  \
                                                                                                    \
                Decimal& operator += ( integralType i )       { return operator+=( Decimal(i) ); }  \
                Decimal& operator -= ( integralType i )       { return operator-=( Decimal(i) ); }  \
                Decimal& operator *= ( integralType i )       { return operator*=( Decimal(i) ); }  \
                Decimal& operator /= ( integralType i )       { return operator/=( Decimal(i) ); }  \
                Decimal& operator %= ( integralType i )       { return operator%=( Decimal(i) ); }


    MARTY_DECIMAL_IMPLEMENT_ARIPHMETICT_OVERLOADS_FOR_INTEGRAL_TYPE( int           )
    MARTY_DECIMAL_IMPLEMENT_ARIPHMETICT_OVERLOADS_FOR_INTEGRAL_TYPE( unsigned      )
    MARTY_DECIMAL_IMPLEMENT_ARIPHMETICT_OVERLOADS_FOR_INTEGRAL_TYPE( std::int64_t  )
    MARTY_DECIMAL_IMPLEMENT_ARIPHMETICT_OVERLOADS_FOR_INTEGRAL_TYPE( std::uint64_t )
    MARTY_DECIMAL_IMPLEMENT_ARIPHMETICT_OVERLOADS_FOR_INTEGRAL_TYPE( float         )
    MARTY_DECIMAL_IMPLEMENT_ARIPHMETICT_OVERLOADS_FOR_INTEGRAL_TYPE( double        )



    int compare( Decimal d2 ) const
    {
        if (m_denum.prec()==d2.m_denum.prec())
        {
            return compare(d2.m_num);
        }

        Decimal d1 = *this;
        adjustPrecisions( d1, d2 );
        return d1.compare(d2);
    }

    MARTY_DECIMAL_IMPLEMENT_RELATIONAL_OPERATORS(Decimal)


    static
    Decimal fromRawNumPrec( num_t num, precision_t prec )
    {
        Decimal res;

        res.m_num   = num;
        res.m_denum = DecimalPrecision(prec);

        return res;
    }


protected:


    Decimal( num_t n, DenumeratorType denum) : m_num(n), m_denum(denum)   {}

    static
    void adjustPrecisions( Decimal &d1, Decimal &d2 )
    {
        int cmp = d1.m_denum.compare( d2.m_denum );
        if (cmp==0) return;

        if (cmp<0)
           d1.expandTo(d2.m_denum.prec());
        else
           d2.expandTo(d1.m_denum.prec());
    }

    std::string rtrimZeros( std::string s )
    {
        while( !s.empty() && s.back()=='0' ) s.erase(s.size()-1, 1);
        if ( !s.empty() && (s.back()=='.' || s.back()==',') )
            s.append(1,'0');
        return s;
    }

    template<typename FloatType>
    void fromFloat( FloatType f, precision_t p )
    {
        bool precAuto = (p==0);
        *this = fromString(rtrimZeros(std::to_string(f)));
        if (!precAuto)
            fitTo(p);
    }

    template<typename FloatType>
    void fromFloat( FloatType f, DecimalPrecision p )
    {
        fromFloat( f, p.prec() );
    }

    int compare( num_t n ) const
    {
        if (m_num<n) return -1;
        if (m_num>n) return  1;
        return 0;
    }

    void expandTo( precision_t p )
    {
        denum_t adjust = m_denum.expandTo(p);
        m_num *= adjust;
    }

    void shrinkTo( precision_t p )
    {
        denum_t adjust = m_denum.shrinkTo(p);
        m_num /= adjust;
    }

    void fitTo( precision_t p )
    {
        sdenum_t adjust = m_denum.fitTo(p);
        if (adjust<0)
           m_num /= (denum_t)-adjust;
        else
           m_num *= (denum_t)adjust;
    }

    void minimizePrecision()
    {
        while( ((m_num%10)==0) && (m_denum.prec()>0) )
        {
            m_num /= 10;
            m_denum.decPrec();
        }
    }


    
    //precision_t

    //DecimalPrecision decimalPrecision( )

    num_t               m_num;
    DenumeratorType     m_denum;

}; // class Decimal

//----------------------------------------------------------------------------





//----------------------------------------------------------------------------
#define MARTY_DECIMAL_IMPLEMENT_FRIEND_OVERLOADS_FOR_INTEGRAL_TYPE( integralType )                                          \
                                                                                                                            \
    inline bool operator< ( integralType i, const Decimal &d ) { return Decimal(i) <  d; }                                  \
    inline bool operator<=( integralType i, const Decimal &d ) { return Decimal(i) <= d; }                                  \
    inline bool operator> ( integralType i, const Decimal &d ) { return Decimal(i) >  d; }                                  \
    inline bool operator>=( integralType i, const Decimal &d ) { return Decimal(i) >= d; }                                  \
    inline bool operator==( integralType i, const Decimal &d ) { return Decimal(i) == d; }                                  \
    inline bool operator!=( integralType i, const Decimal &d ) { return Decimal(i) != d; }                                  \
                                                                                                                            \
    inline Decimal operator + ( integralType i, const Decimal &d ) { return Decimal(i).operator+ ( d ); }                   \
    inline Decimal operator - ( integralType i, const Decimal &d ) { return Decimal(i).operator- ( d ); }                   \
    inline Decimal operator * ( integralType i, const Decimal &d ) { return Decimal(i).operator* ( d ); }                   \
    inline Decimal operator / ( integralType i, const Decimal &d ) { return Decimal(i).operator/ ( d ); }                   \
    inline Decimal operator % ( integralType i, const Decimal &d ) { return Decimal(i).operator% ( d ); }

//----------------------------------------------------------------------------




//----------------------------------------------------------------------------
MARTY_DECIMAL_IMPLEMENT_FRIEND_OVERLOADS_FOR_INTEGRAL_TYPE( int           )
MARTY_DECIMAL_IMPLEMENT_FRIEND_OVERLOADS_FOR_INTEGRAL_TYPE( unsigned      )
MARTY_DECIMAL_IMPLEMENT_FRIEND_OVERLOADS_FOR_INTEGRAL_TYPE( std::int64_t  )
MARTY_DECIMAL_IMPLEMENT_FRIEND_OVERLOADS_FOR_INTEGRAL_TYPE( std::uint64_t )
MARTY_DECIMAL_IMPLEMENT_FRIEND_OVERLOADS_FOR_INTEGRAL_TYPE( float         )
MARTY_DECIMAL_IMPLEMENT_FRIEND_OVERLOADS_FOR_INTEGRAL_TYPE( double        )

//----------------------------------------------------------------------------




//----------------------------------------------------------------------------
inline
void swap( Decimal &d1, Decimal &d2 )
{
    d1.swap(d2);
}

//----------------------------------------------------------------------------
inline
std::string toString  ( const Decimal     &d )
{
    Decimal::num_t p1 = d.m_num / d.m_denum.denum();
    Decimal::num_t p2 = d.m_num % d.m_denum.denum();

    std::string res = std::to_string(p1);

    std::size_t prec = d.m_denum.prec();

    if (!prec)
        return res; // No decimal digits after dot

    if (p2<0)
        p2 = -p2;

    std::string strP2 = std::to_string(p2);

    std::size_t leadingZerosNum = 0;
    if (prec>strP2.size())
        leadingZerosNum = prec - strP2.size();

    return res + std::string(1, '.') + std::string(leadingZerosNum, '0') + strP2;
}

//----------------------------------------------------------------------------
template<typename CharType>
inline
int charToDecimalDigit( CharType ch )
{
    if (ch<(CharType)'0') return -1;
    if (ch>(CharType)'9') return -1;
    return (int)(ch - (CharType)'0');
}

//----------------------------------------------------------------------------
template<typename CharType>
inline
bool charIsDecimalSeparator( CharType ch )
{
    if (ch==(CharType)'.') return true;
    if (ch==(CharType)',') return true;
    return false;
}

//----------------------------------------------------------------------------
template<typename CharType>
inline
int charIsSpaceOrTab( CharType ch )
{
    switch((char)ch)
    {
        case ' ' : return true;
        case '\t': return true;
        default  : return false;
    };
}

//----------------------------------------------------------------------------
inline
Decimal     fromString( const std::string &numberStr)
{
    std::string::size_type pos = 0;
    std::string::size_type sz  = numberStr.size();

    bool neg = false;

    while( charIsSpaceOrTab(numberStr[pos]) && pos!=sz ) pos++;
    if (pos==sz) throw std::runtime_error("Decimal fromString - empty string taken as number string");

    if (numberStr[pos]=='+')                        { pos++; }
    else if (numberStr[pos]=='-')                   { pos++; neg = true; }
    else if (charToDecimalDigit(numberStr[pos])>=0) {}
    else throw std::runtime_error("Decimal fromString - invalid character found");

    while( charIsSpaceOrTab(numberStr[pos]) ) pos++;

    std::int64_t  num = 0;
    std::uint32_t precision = 0;

    int dig = charToDecimalDigit(numberStr[pos]);
    while(dig>=0)
    {
        num *= 10;
        num += (std::int64_t)dig;
        pos++;
        dig = charToDecimalDigit(numberStr[pos]);
    }

    if (neg)
        num = -num;

    if (!charIsDecimalSeparator(numberStr[pos]))
    {
        return Decimal( num, DecimalPrecision(0) );
    }

    pos++;

    unsigned prec = 0;

    dig = charToDecimalDigit(numberStr[pos]);
    while( sz != pos && (dig>=0  /* && (d[pos]!=' ' && d[pos]!='\'') */ ) )
    {
        num *= 10;
        num += (std::int64_t)dig;
        pos++;
        dig = charToDecimalDigit(numberStr[pos]);
        prec++;
    }

    return Decimal::fromRawNumPrec( num, prec );

}

//----------------------------------------------------------------------------
inline
std::ostream& operator<<( std::ostream &s, const Decimal &d )
{
    s<<toString(d);
    return s;
}

//----------------------------------------------------------------------------




//----------------------------------------------------------------------------

} // namespace marty

#include <iostream>
#include "marty_decimal.h"

int main()
{
    using std::cout;
    using std::endl;

    using std::cout;
    using std::endl;

    using marty::Decimal;
    using marty::DecimalPrecision;
    using marty::toString;
    using marty::fromString;

    #define PRINT( var ) cout << #var << ": "<< var << endl;

    Decimal d1_u64_3   = (std::uint64_t)(3)  ; PRINT(d1_u64_3);
    Decimal d1_i64_7   = (std::int64_t )(7)  ; PRINT(d1_i64_7);
    Decimal d1_i64_m10 = (std::int64_t )(-10); PRINT(d1_i64_m10);
    Decimal d1_i64_15_000 = Decimal(15, DecimalPrecision(3)); PRINT(d1_i64_15_000);
    Decimal d1 = fromString("123.010");        PRINT(d1);
    Decimal d2 = fromString("13.10");          PRINT(d2);
    Decimal d1_2_sum = d1 + d2;                PRINT(d1_2_sum);  // 123.010 + 13.10 =  136.11
    Decimal d1_2_raz = d1 - d2;                PRINT(d1_2_raz);  // 123.010 - 13.10 =  109.91
    Decimal d1_2_mul = d1 * d2;                PRINT(d1_2_mul);  // 123.010 * 13.10 = 1611.431
    Decimal d1_2_div = d1 / d2;                PRINT(d1_2_div);  // 123.010 / 13.10 =    9.390076335877862595419847328
    Decimal d1_2_ost = d1 % d2;                PRINT(d1_2_ost);  // 123.010 % 13.10 =    5.11

    auto    d1_2_sum_plus_15_a = d1_2_sum + (std::int64_t )(15); PRINT(d1_2_sum_plus_15_a);
    auto    d1_2_sum_plus_15_b = d1_2_sum + (std::uint64_t)(15); PRINT(d1_2_sum_plus_15_b);
    auto    d1_2_sum_plus_15_c = d1_2_sum + (int          )(15); PRINT(d1_2_sum_plus_15_c);
    auto    d1_2_sum_plus_15_d = d1_2_sum + (unsigned     )(15); PRINT(d1_2_sum_plus_15_d);
    auto    d1_2_sum_plus_15_e = d1_2_sum + (double       )(15); PRINT(d1_2_sum_plus_15_e);
    
    return 0;

}

Сборка/отладка/логгировани firefox из исходников под Ubuntu

Thu, 09 May 2019 08:11:49 GMT

Надеюсь описанное ниже никогда вам не понадобится

1)Копируем source пакет firefox-а в текущую папку

sudo apt-get build-dep firefox
sudo apt-get install -y fakeroot
apt-get source firefox

2)можно попробовать пофиксать параметры mach-а в файле debian/config/mozconfig.in перед тем как запустить build. например можно сделать дебажный билд как описано тут https://developer.mozilla.org/en-US/docs/Mozilla/Developer_guide/Build_Instructions/Simple_Firefox_build/Linux_and_MacOS_build_preparation
Так же можно если надо ограничить число ядер задействованных в билде. В моем случае если на задать этот параметр на ноуте невозможно работать пока идет билд. Я бы поставил его в число доступных ядер — 20-30%, например так

mk_add_options MOZ_MAKE_FLAGS="-j4

как описано тут здесь

3)Билдаем

dpkg-buildpackage -b -us -uc

это займет кучу времени. У меня такой билд прошел нормально, а билд по инструкции firefox-а на том же релизе сфейлился. Видимо что-то maintainer-ы пакета пофиксали в патчах для пакета(а их было штук 5. не разбирался, когда построилось просто был рад), потому что билдил все на той же тачке. Да и вообще билдить это все лучше в контейнере, чтобы если что-то пошло не так снести его и не угробить рабочую машину. Я использовал LXD и новый контейнер 18.04 в нем.

Эта часть инструкции заимствована преимущественно отсюда
здесь

После успешной постройки артифакты билда лежат в папке obj-x86_64-linux-gnu
Бинарники firefox-а в папке obj-x86_64-linux-gnu/dist/bin

Если перестраивать код после фиксов, в например папке media, перестраивается только библиотека libxul.so. Линкуется она кучу времени.

Чтобы построить только те файлы, которые поменял, например в libpng и не ждать линковки каждый раз идем в фолдер
obj-x86_64-linux-gnu/media/libpng, чтобы make не ходил по неизмененным папкам, чтобы проверить что они не менялись
и делаем
make

после того как фиксы скомпилировались и мы хотим пересобрать libxul.so идем в корневой фолдер и делаем
make
джем кучу времени пока она слинкуется

запускается все это добро как обычно
./mach run

Статья про отладку https://developer.mozilla.org/en-US/docs/Mozilla/Debugging/Debugging_Mozilla_with_gdb надеюсь вам это не понадобится
Надеюсь что хватит логгирования здесь

Mortal Kombat 3

Thu, 25 Oct 2018 20:34:51 GMT

https://archive.org/download/MortalKombat3SourceCodeDump

Mecrurial: Ограниченная версия репозитория для нового удалённого сотрудника.

Mon, 07 May 2018 08:27:08 GMT

Здравствуйте,

Есть Mercurial репозиторий с программным решением, который используется внутри компании ограниченным кругом разработчиков.
В данном репозитории есть конфигурационные файлы с подключением к БД.
В данный момент планируем привлеч к разработке удалённого сотрудника. Но есть необходимость ограничить его доступ к основной БД.
Решили запустить новый инстанс с БД, куда будут реплицироваться данные с основной БД.
К данной БД дать доступ удалённому разработчику для его экспериментов.

Хотим скрыть данные о подключении к основной БД, но они есть в истории.
Ищу решение этой проблемы. Как вариант теоретически это может быть ещё одна версия репозитория, с которой можно будет каким-то образом мержить основную версию.

Прошу посоветовать решение для этой проблемы.

Suspender

Tue, 05 Jan 2016 22:07:06 GMT

Коллеги, привет!

https://github.com/devromik/suspender

Небольшая библиотека на Java, позволяющая:

откладывать произвольные объекты на определённое время, используя путь (строка вида /segment_1/segment_2/…/segment_N) в качестве ключа
получать оповещения о восстановлении объектов
восстанавливать объекты, отложенные по префиксу, до истечения времени откладывания. Префикс — путь, состоящий из нескольких первых сегментов другого пути, расположенных в том же порядке. Объекты, отложенные по префиксу, — объекты, отложенные по путям с данным префиксом
восстанавливать отложенный по префиксу объект с ближайшим временем восстановления
проверять, имеются ли объекты, отложенные по префиксу
восстанавливать все объекты, отложенные по префиксу
concurrent: после того, как Suspender создан и запущен, можно работать с ним из нескольких потоков без ограничений. Реализация с этой точки зрения fine-grained — на практике блокировки удерживаются только на время поиска узла дерева отложенных объектов, соответствующего данному пути
покрыта тестами на 95%

Использовали в паре проектов на работе.

Имеется зависимость от библиотеки slf4j-utils, которой в центральном Maven-репозитории нет. Найти её можно здесь: https://github.com/devromik/slf4j-utils
Библиотека малюсенькая, при желании можно выпилить, заменив на что-то своё.

pom.xml имеет несколько профилей, которые я обыкновенно использую в своих проектах.
Поэтому, прежде чем собирать, желательно заглянуть в этот файлик.

Более подробное описание библиотеки можно найти в заголовочном комментарии к интерфейсу Suspender.

P. S.: приветствуются вопросы, pull-request-ы, замечания, предложения

[C# 4 и 3] Построитель компараторов [Bug fixed]

Sun, 22 Mar 2015 03:40:49 GMT

По мотивам [C# 4 и 3] Построитель компараторов (Я так понимаю, на страрую тему запретили отвечать? Создам на всякий случай новую)

В компараторе внезапно обнаружилась древняя бага, проявляющаяся в создаваемом Comparer<>-е при сравнении нуллейбл-полей (сравнение проходит не верно). С EqualityComparer<> всё отлично (ошибок за всё время активного использования с момента создания выявлено не было).

Фикс следующий

// 1. Вместо старых функций IsNull и IsNotNull делаем новые:

private static BinaryExpression IsNull(Expression expression) {
  if(expression == null) {
    throw new ArgumentNullException("expression");
  }//if

  if(IsTypeByReference(expression)) {
    return Expression.ReferenceEqual(expression, Null);
  } else {
    return Expression.Equal(expression, Null);
  }//if
}

private static BinaryExpression IsNotNull(Expression expression) {
  if(expression == null) {
    throw new ArgumentNullException("expression");
  }//if

  if(IsTypeByReference(expression)) {
    return Expression.ReferenceNotEqual(expression, Null);
  } else {
    return Expression.NotEqual(expression, Null);
  }//if
}

private static bool IsTypeByReference(Expression expression) {
  if(expression == null) {
    throw new ArgumentNullException("expression");
  }//if

  return IsTypeByReference(expression.Type);
}

private static bool IsTypeNullable(Expression expression) {
  if(expression == null) {
    throw new ArgumentNullException("expression");
  }//if

  var type = expression.Type;
  return IsTypeByReference(type) || type.IsValueType && Nullable.GetUnderlyingType(type) != null;
}

private static bool IsTypeByReference(Type type) {
  if(type == null) {
    throw new ArgumentNullException("type");
  }//if

  return type.IsClass || type.IsInterface;
}

// 2. Метод MakeCompare<P> должен быть таким (изменена ветка else)

protected virtual Expression MakeCompare<P>(Expression left, Expression right, IComparer<P> comparer) {
  if(left == null) {
    throw new ArgumentNullException("left");
  } else if(right == null) {
    throw new ArgumentNullException("right");
  }//if

  if(comparer != null) {
    // return comparer.Compare(left, right);
    Func<P, P, int> @delegate = comparer.Compare;
    var instance = Expression.Constant(comparer);
    return Expression.Call(instance, @delegate.Method, left, right);
  } else {
    // (left < right) ? -1 : (right < left ? 1 : 0);
    var compare = Expression.Condition(Expression.LessThan(left, right), MinusOne, Expression.Condition(Expression.LessThan(right, left), One, Zero));
    var code = (IsTypeNullable(left) ? 2 : 0) + (IsTypeNullable(right) ? 1 : 0);
    switch(code) {
    case 0: // "left" and "right" both are not nullable
      return compare;
    case 1: // "left" is not nullable and "right" is nullable
      // (object)right == null ? 1 : {compare};
      return Expression.Condition(IsNull(right), One, compare);
    case 2: // "left" is nullable and "right" is not nullable
      // (object)left == null ? -1 : {compare};
      return Expression.Condition(IsNull(left), MinusOne, compare);
    case 3: // "left" and "right" both are nullable
      // (object)left == null ? (right == null ? 0 : -1) : ((object)right == null ? 1 : {compare});
      return Expression.Condition(IsNull(left), Expression.Condition(IsNull(right), Zero, MinusOne), Expression.Condition(IsNull(right), One, compare));
    default:
      const string Format = "Invalid code: left.Type = {0}, right.Type = {1}, code = {2}.";
      var message = String.Format(Format, left.Type, right.Type, code);
      Debug.Fail(message);
      throw new InvalidOperationException(message);
    }//switch
  }//if
}

Тест для проверки:

class BaseData
{
  public BaseData(DateTime? test = null) {
    Test = test;
  }

  public DateTime? Test { get; private set; }
}

public static void CompareNullableProperty() {
  var comparer = new ComparerBuilder<BaseData>().Add(value => value.Test).ToComparer();
  var items = new[] {
    new BaseData(null),
    new BaseData(new DateTime(2015, 01, 01)),
    new BaseData(null),
    new BaseData(new DateTime(2015, 02, 01)),
    new BaseData(null),
    new BaseData(new DateTime(2015, 03, 01)),
  };
  Array.Sort(items, comparer);
  var previous = default(BaseData);
  foreach(var item in items) {
    if(previous != null) {
      Debug.Assert(previous.Test == null || previous.Test <= item.Test,String.Format("previous.Test2 == null || previous.Test2 [{0}] <= item.Test2 [{1}]", previous.Test, item.Test));
    }//if
    previous = item;
  }//for
}

Проект, кстати, теперь есть на гитхабе, но уже на шестом шарпе, но уже и не такой куцый.

Edit: Исправил код, убрав nameof и переименов вспомагательный метод.

Собственный встраиваемый скриптинг

Thu, 12 Mar 2015 14:31:24 GMT

По работе пришлось писать встраиваемый парсер для скриптового языка. Lua и иже с ним не пошёл так как нужно было для разных пользователей разную функциональность, а стандартные функции Lua не так уж просто из него убрать. В общем попробовал написать свой и оказалось, что дело несложное. Идею взял
здесь. Парсер состоит из управляющего модуля и модулей занимающих парсингом. Можно сделать очень простой язык, можно сложный, зависит от набора модулей для парсинга. Обычно модуль это один файл содержащий в среднем 200 строк С-кода. В общем вещь достаточно тривиальная однако с её помощью можно делать сложные вещи (в моём случае даже лямбда-функции поддерживаются), самое приятное в том, что парсер самодокументирующийся. В сложных проектах документация постоянно отстаёт от кода, а здесь парсер всегда может выдать текущий синтаксис языка.

Начальство не возражало против выкладывания исходников для парсера в открытый доступ, так что я его кинул на sourceforge. Лежит здесь. Чтобы совсем уж не было всё голым слепил интерпретатор читающий скрипты из файла и выполняющий их. Для иллюстрации возможностей удалённого запуска процедур (RPC) сделал сервер для хранения файлов. Получение или загрузка файлов делается с помощью скриптов. Это значит, что можно запросить файл сжатый в bzip2 а затем закодированный MIME::Base64 или зашифрованный с помощью AES. В общем, игрушка

Код написан на С, под Линукс. Документация кое-какая есть, правда на английском (писано для работодателя). В общем, может кому пригодится.

Подсчёт CRC для Тензо

Mon, 29 Sep 2014 12:42:47 GMT

Перевод малюсенькой функции подсчёта CRC для кадра данных терминалов Тензо ТВ-006, Тензо ТВ-009, Тензо ТВ-011 из ассемблера MASM 6.x (входит в Visual C++ 6.0) в ассемблер GCC Inline Assembly (встроен в компиляторы GNU C, MinGW C++ ).

// MinGW C++

BYTE CRCMaker(BYTE b_input,BYTE b_CRC){
    asm volatile("movb %0,%%al"::"g"(b_input));
    asm volatile("movb %0,%%ah"::"g"(b_CRC));
    asm volatile("mov $8,%cx");
    asm volatile("mod1: rol $1,%al");
    asm volatile("rcl $1,%ah");
    asm volatile("jnc mod2");
    asm volatile("xor $0x69,%ah");
    asm volatile("mod2: dec %cx");
    asm volatile("jnz mod1");
    asm volatile("movb %%ah,%0":"=g"(b_CRC));
    return b_CRC;}

	Оригинал
	Из документации: `// Visual C++ BYTE CRCMaker(BYTE b_input,BYTE b_CRC){ _asm{ mov al,b_input mov ah,b_CRC mov cx,8 mod1: rol al,1 rcl ah,1 jnc mod2 xor ah,69h mod2: dec cx jnz mod1 mov b_CRC,ah } return b_CRC;}`

Сброс битмапов.

Wed, 30 Oct 2013 16:16:07 GMT

Иногда бывает нужно в коде в целях отладки сбрасывать какие то изображения что бы посмотреть.
Например бывает очень нужно в OpenGL приложениях посмотреть что ушло в текстуру или что там получилось.
Во общем кидаю парочку простых функций для дампа в ppm/pbm которые можно быстро вставить и скомпилить.
Может кому то пригодится, одно замечание 32-битные изображения не могут быть сохранены в ppm/pbm формате и будут сконвертированы в 24-битные.

Скрытый текст

unsigned short calculate_stride(unsigned int w, unsigned char bypp)
{
    unsigned short pitch = 0;

    pitch = w * bypp;
    switch (bypp<<3)
    {
    case 1: pitch = (pitch+7)/8; break;
    case 4: pitch = (pitch+1)/2; break;
    }

    // 4-byte aligning
    pitch = (pitch + 3) & ~3;
    return pitch;
}


struct cm_RGB_2_RGB {
    enum {
        r = 0, g = 1, b = 2
    };
};

struct cm_BRG_2_RGB {
    enum {
        r = 1, g = 2, b = 0
    };
};

struct cm_BGR_2_RGB {
    enum {
        r = 2, g = 1, b = 0
    };
};

template< typename color_model >
bool    graphics_algs::export_2ppm( unsigned int w, unsigned int h, int stride, unsigned char bypp, const void* data, std::ostream& stream )
{
    assert( stream.good() && stream.flags() & std::ios::binary|std::ios::out);
    if( !stream.good() ) return false;

    stream << (1 == bypp ? "P5" : "P6") << "\n";
    stream << w << "\n" << h << "\n";
    stream << 255 << "\n";

    if(4 == bypp) { //convert to 24 bit PPM

        const unsigned short new_stride = calculate_stride(w, 3);

        for(unsigned int r = 0;  r < h; ++r)
        {
            const unsigned char *_data = (const unsigned char*)data + (r*stride);
            for(unsigned int c = 0; c < w; ++c)
            {
                stream.put(*(_data+c*4+color_model::r));
                stream.put(*(_data+c*4+color_model::g));
                stream.put(*(_data+c*4+color_model::b));
            }

            for(int s = 0; s < new_stride - (w*3); ++s) {
                stream.put(0);
            }
        }

    } else {
        for(unsigned int y = 0; y < h; y++) {
            stream.write( (const char*)data + y * stride, w * bypp);
        }
    }

    return true;
}

jquery.RuEn.js

Wed, 16 Oct 2013 11:03:38 GMT

Написал плагин под JQuery, наверно кому-то будет интересно.
Вешается на текстовое поле, при вводе преобразует русские буквы в латинские. Полезно при вводе Email, например, можно не переключать языки ввода. Или в полях, где должна быть только латиница.
Бонусом ввод "@" кнопкой "~"("Ё").
Можно ругать, js только осваиваю

(function ($)
{
    $.fn.ruEn = function ()
    {
        var charMap = {
            "й": "q",
            "ц": "w",
            "у": "e",
            "к": "r",
            "е": "t",
            "н": "y",
            "г": "u",
            "ш": "i",
            "щ": "o",
            "з": "p",
            "ф": "a",
            "ы": "s",
            "в": "d",
            "а": "f",
            "п": "g",
            "р": "h",
            "о": "j",
            "л": "k",
            "д": "l",
            "я": "z",
            "ч": "x",
            "с": "c",
            "м": "v",
            "и": "b",
            "т": "n",
            "ь": "m",
            "Й": "Q",
            "Ц": "W",
            "У": "E",
            "К": "R",
            "Е": "T",
            "Н": "Y",
            "Г": "U",
            "Ш": "I",
            "Щ": "O",
            "З": "P",
            "Ф": "A",
            "Ы": "S",
            "В": "D",
            "А": "F",
            "П": "G",
            "Р": "H",
            "О": "J",
            "Л": "K",
            "Д": "L",
            "Я": "Z",
            "Ч": "X",
            "С": "C",
            "М": "V",
            "И": "B",
            "Т": "N",
            "Ь": "M",
            "ю": ".",
            "Ю": ".",
            "ё": "@",
            "Ё": "@"
        };
        return this.each(function ()
        {
            var $this = $(this);
            $this.on("keypress", function (event)
            {
                if (event.which) {
                    var charStr = String.fromCharCode(event.which);
                    var transformedChar = transformTypedCharacter(charStr);
                    if (transformedChar != charStr) {
                        var sel = getInputSelection(this);
                        this.value = this.value.slice(0, sel.start) + transformedChar + this.value.slice(sel.end);
                        // Move the caret
                        setInputSelection(this, sel.start + 1, sel.start + 1);
                        return false;
                    }
                }
            });
        });

        function transformTypedCharacter(typedChar)
        {
            return charMap[typedChar] || typedChar;
        }

        function setInputSelection(el, startOffset, endOffset)
        {
            el.focus();
            if (typeof el.selectionStart == "number" && typeof el.selectionEnd == "number") {
                el.selectionStart = startOffset;
                el.selectionEnd = endOffset;
            } else {
                var range = el.createTextRange();
                var startCharMove = offsetToRangeCharacterMove(el, startOffset);
                range.collapse(true);
                if (startOffset == endOffset)
                    range.move("character", startCharMove);
                else {
                    range.moveEnd("character", offsetToRangeCharacterMove(el, endOffset));
                    range.moveStart("character", startCharMove);
                }

                range.select();
            }
        }

        function offsetToRangeCharacterMove(el, offset)
        {
            return offset - (el.value.slice(0, offset).split("\r\n").length - 1);
        }

        function getInputSelection(el)
        {
            var start = 0, end = 0, normalizedValue, range,
                textInputRange, len, endRange;

            if (typeof el.selectionStart == "number" && typeof el.selectionEnd == "number") {
                start = el.selectionStart;
                end = el.selectionEnd;
            } else {
                range = document.selection.createRange();

                if (range && range.parentElement() == el) {
                    len = el.value.length;
                    normalizedValue = el.value.replace(/\r\n/g, "\n");

                    // Create a working TextRange that lives only in the input
                    textInputRange = el.createTextRange();
                    textInputRange.moveToBookmark(range.getBookmark());

                    // Check if the start and end of the selection are at the very end
                    // of the input, since moveStart/moveEnd doesn't return what we want in those cases
                    endRange = el.createTextRange();
                    endRange.collapse(false);

                    if (textInputRange.compareEndPoints("StartToEnd", endRange) > -1)
                        start = end = len;
                    else {
                        start = -textInputRange.moveStart("character", -len);
                        start += normalizedValue.slice(0, start).split("\n").length - 1;

                        if (textInputRange.compareEndPoints("EndToEnd", endRange) > -1)
                            end = len;
                        else {
                            end = -textInputRange.moveEnd("character", -len);
                            end += normalizedValue.slice(0, end).split("\n").length - 1;
                        }
                    }
                }
            }

            return { start: start, end: end };
        }
    };
})(jQuery);

Cloneable

Sun, 21 Apr 2013 08:55:59 GMT

Не претендуя на новизну, больше на новичков

Оператор копирования и паттерн Прототип

Интуитивное копирование

Заводим общую функцию для конструктора копирования и оператора присваивания:

class C {
public:
    C(const C &rhs) {
        CopyFrom(rhs);
    }
 
    C &operator = (const C &rhs) {
        CopyFrom(rhs);
        return *this;
    }
 
    void CopyFrom(const C &rhs) {
        //копируем данные
    }
};

Безопасное копирование

"В каждой функции следует собрать весь код, который может генерировать исключения, и выполнить его отдельно, безопасным с точки зрения исключений способом. Только после этого, когда вы будете знать, что вся реальная работа успешно выполнена, вы можете изменять состояние программы (а также выполнять другие необходимые действия, например, освобождение ресурсов) посредством операций, которые не генерируют исключений." [Герб Саттер, с. 122]
Соответствующая реализация "copy and swap" следует идиоме RAII (получение ресурса есть инициализация) [Мейерс, правило 13] и требует реализации конструктора копирования и функции Swap:

class C {
public:
    C(const C &rhs) {
        //код инициализации
    }
 
    C &operator = (const C &rhs) {
        C temp(rhs);
        Swap(temp);
        return *this;
    }
 
    void Swap(C &rhs) throw() {
        //обмениваем указатели
    }
};

Элегантное копирование

template<typename T>
class Cloneable {
public:
    typedef Cloneable<T> baseClass;
 
    Cloneable() {}
 
    explicit Cloneable(const Cloneable &) {}
 
    virtual ~Cloneable() {}
 
    static T *New() {
        return new T;
    }
 
    T &operator = (const T &rhs) {
        if (This() != &rhs) {
            T temp(rhs);
            Swap(temp);
        }
        return *This();
    }
 
    virtual T *Clone() {
        return new T(*This());
    }
 
    virtual void Swap(T &) = 0;
 
    virtual T* This() = 0;
};
 
 
class C : public Cloneable<C> {
public:
    C(const C &rhs) {
        //код инициализации
    }
 
    C *This() {
        return this;
    }
 
    void Swap(C &rhs) throw() {
        //обмениваем указатели
    }
};

Ссылки

Герб Саттер, Решение сложных задач на C++. Изд. Вильямс, 2002.
Скотт Мейерс. Эффективное использование C++. 55 верных советов улучшить структуру и код ваших программ, 2006.

DLLINFO -Big Trouble -загружает трой!?.

Sat, 17 Nov 2012 09:21:49 GMT

Внимание! Имел у себя продолжительное время эту длл-ку и не мог нарадоваться. Недавно подхватил вирь со стр. в браузере. Вычислил и вычистил все файлы и сложил в папку. Но вот беда, при открытии браузером для отправки на сайт www.virustotal.com получил непонятные глюки(браузеры или зависают, или вырубаются). Выяснил, что как браузер, так и Totalcmd, так и Explorer загружают эту дллку(трой) в адресное пространство на исполнение, после чего все начинает глючить. Переименование не помогает. Обнаружил, что это именно dllinfo.dll осуществляют эту загрузку. Т.к. при выгрузке ее из памяти, загрузка троя прекращается.

В исходниках не ковырялся, да и я не большой спец.

[ruby] выгрузка данных по логам ProcessMonitor

Wed, 31 Oct 2012 06:36:18 GMT

После выхода новой версии ProcessMonitor обнаружил, что теперь формат логов изменился. Вариантов выгрузки стало три XML,CSV и нативный формат тула. Решил CSV запарсировать.

у тула два параметра
1) лог в формате csv
2) директория куда пойдет output

тул удобен когда важно понять не только откуда читается, но и что

require "fileutils"

def processLog(file_name, len_offset)
  len_offset_params = len_offset.split /,/
  len    = (len_offset_params[1].split /:/)[1].gsub(/\u00A0/, "").gsub(/\s+/, "").gsub(/"/, "")
  offset = (len_offset_params[0].split /:/)[1].gsub(/\u00A0/, "").gsub(/\s+/, "").gsub(/"/, "")
  begin
    buffer = nil
    File.open file_name, 'rb' do |file|
      file.seek offset.to_i, IO::SEEK_SET
      buffer = file.read len.to_i
      $map_file.write("#{$log_file_num} #{file_name} #{offset} #{len}\n")
    end

    File.open $log_file_num.to_s, 'wb' do |file|
      file.write buffer
    end
  rescue Exception => e
    p e.class
  end
end

p "call me ruby Logfile.CSV output_dir" and exit if ARGV.length != 2

lines = nil

File.open ARGV[0], 'r:bom|utf-8' do |file|
  lines = file.readlines
end
lines.delete_at 0 # lets remove the first line

output_directory = ARGV[1]
FileUtils.mkdir(output_directory) if !File.directory?(output_directory)
Dir.chdir output_directory

$map_file = File.open "map.txt", 'w'
$map_file.write "\xEF\xBB\xBF"

$log_file_num = 0
lines.each {|line|
  params = line.split '","'
  next if !params[3].eql?('ReadFile')
  processLog params[4], params[6]
  $log_file_num+=1
}

$map_file.close

RetroEvent - позволяющий делать операции в процессе ожидания

Wed, 26 Sep 2012 23:02:27 GMT

Идея проста: позволить двойную проверку(double check).

RetroEvent.h

#pragma once

#include <Windows.h>
#include <intrin.h>

class RetroEvent
{
public:
    RetroEvent();
    ~RetroEvent();

    __int64 RequestWait();
    DWORD PerformWait(__int64 index, DWORD timeout);
    void Set();
private:
    __int64 m_setIndex, m_waitIndex, m_waitingCount;
    HANDLE m_eventHandle;
};

RetroEvent.cpp

#include "stdafx.h"
#include "RetroEvent.h"

RetroEvent::RetroEvent()
{
    m_eventHandle = CreateEvent(NULL, TRUE, FALSE, NULL);
    m_setIndex = 0;
    m_waitIndex = 0;
    m_waitingCount = 0;
}
RetroEvent::~RetroEvent()
{
    CloseHandle(m_eventHandle);
}

__int64 RetroEvent::RequestWait()
{
    return ::InterlockedIncrement64(&m_waitIndex);
}
DWORD RetroEvent::PerformWait(__int64 index, DWORD timeout)
{
    DWORD begin = GetTickCount();
    DWORD res = STATUS_WAIT_0;
    while (true)
    {
        ::InterlockedIncrement64(&m_waitingCount);
        if (::InterlockedCompareExchange64(&m_setIndex,  0, 0) > index)
        {
            ::InterlockedDecrement64(&m_waitingCount);
            break;
        }

        DWORD now = GetTickCount();
        if ((now - begin) > timeout)
        {
            ::InterlockedDecrement64(&m_waitingCount);
            SetLastError(WAIT_TIMEOUT);
            res = WAIT_TIMEOUT;
            break;
        }
        DWORD toWait = timeout - (now - begin);
        res = WaitForSingleObject(m_eventHandle, toWait);
        if (res != STATUS_WAIT_0)
        {
            ::InterlockedDecrement64(&m_waitingCount);
            break;
        }    
        
        if(::InterlockedDecrement64(&m_waitingCount) == 0)
            continue;


        while (::InterlockedCompareExchange64(&m_waitingCount, 0, 0)) SwitchToThread();
    } 
    return res;

}
void RetroEvent::Set()
{
    __int64 setIndex = RequestWait();
    __int64 prevIndex = m_setIndex;
    if (prevIndex > setIndex)
        return;
    if (::InterlockedCompareExchange64(&m_setIndex,  setIndex, prevIndex) != prevIndex)
        return;
    ::InterlockedIncrement64(&m_waitingCount);
    SetEvent(m_eventHandle);
    while (::InterlockedCompareExchange64(&m_waitingCount, 0, 0) > 1) 
    {
        if (::InterlockedCompareExchange64(&m_setIndex,  0, 0) != setIndex)
        {
            ::InterlockedDecrement64(&m_waitingCount);
            return;
        }        
        SwitchToThread();
    }
    ResetEvent(m_eventHandle);
    ::InterlockedDecrement64(&m_waitingCount);
}

Буду рад как критике, так и ссылкам на другие готовые реализации.

[java] Пример proxy на асинхронных сокетах

Thu, 13 Sep 2012 00:19:05 GMT

Но основе этого пример планировалось делать проброс JMX/RMI трафика между хостами.
Для примера запускается приложение с jmx path service:jmx:rmi://localhost:8084/jndi/rmi://localhost:8085/jmxrmi
Приложение ниже должно было слушать на портах 9000 и 9001 и пробрасывать весь трафик в обе стороны чтобы можно было соединиться
с помощью jconsole к портам 9000 и 9001 соответственно. Пример сырой но вполне рабочий чтобы понять что подходработает

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.*;

public class Main {

    static Map<Integer, Integer> portMap = new HashMap<Integer, Integer>();

    static Map<SocketChannel, SocketChannel> proxy2JmxMap = new HashMap<SocketChannel, SocketChannel>();

    static Map<SocketChannel, SocketChannel> jmx2ProxyMap = new HashMap<SocketChannel, SocketChannel>();

    static Map<SocketChannel, List<byte[]>> writeOrder = new HashMap<SocketChannel, List<byte[]>>();


    private static void accept(SelectionKey key) throws IOException {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();

        Integer jmxPort = portMap.get(serverChannel.socket().getLocalPort());

        if(jmxPort == null)
        {
            serverChannel.close();
            key.cancel();
            return;
        }

        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);
        socketChannel.connect(new InetSocketAddress("127.0.0.1", jmxPort));
        socketChannel.register(key.selector(), SelectionKey.OP_CONNECT);

        SocketChannel channel = serverChannel.accept();
        channel.configureBlocking(false);

        jmx2ProxyMap.put(socketChannel, channel);
        proxy2JmxMap.put(channel, socketChannel);

        channel.register(key.selector(), SelectionKey.OP_READ);
    }

    private static void connect(SelectionKey key) {
        SocketChannel sChannel = (SocketChannel)key.channel();

        boolean success = false;
        try {
            success = sChannel.finishConnect();
        } catch (IOException e) {
            e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
        }
        if (!success) {
            // An error occurred; handle it

            // Unregister the channel with this selector
            key.cancel();
        }
        int ops = key.interestOps();

        if((ops & SelectionKey.OP_WRITE) != 0)
        {
            key.interestOps(SelectionKey.OP_WRITE);
        }
        else
        {
            key.interestOps(SelectionKey.OP_READ);
        }
    }

    private static void read(SelectionKey key) throws IOException {

        SocketChannel source = (SocketChannel) key.channel();
        SocketChannel destination = jmx2ProxyMap.get(source);

        if(destination == null)
        {
            destination = proxy2JmxMap.get(source);
        }
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int numRead = -1;

        try {
            numRead = source.read(buffer);
        }
        catch (IOException e) {
            e.printStackTrace();
        }

        if (numRead == -1) {
            source.close();
            key.cancel();
            return;
        }

        List<byte[]> order = writeOrder.get(destination);
        if(order == null)
        {
            order = new ArrayList<byte[]>();
            writeOrder.put(destination, order);
        }

        byte[] data = new byte[numRead];
        System.arraycopy(buffer.array(), 0, data, 0, numRead);

        order.add(data);

        SelectionKey destkey = destination.keyFor(key.selector());

        destkey.interestOps(SelectionKey.OP_WRITE);
    }

    private static void write(SelectionKey key) throws IOException {
        SocketChannel channel = (SocketChannel) key.channel();
        List<byte[]> pendingData = writeOrder.get(channel);
        Iterator<byte[]> items = pendingData.iterator();
        while (items.hasNext()) {
            byte[] item = items.next();
            items.remove();
            channel.write(ByteBuffer.wrap(item));
        }
        key.interestOps(SelectionKey.OP_READ);
    }


    public static void main(String[] args) throws Exception {
        Selector proxySelector = Selector.open();

        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        // bind to port
        InetSocketAddress listenAddr = new InetSocketAddress((InetAddress)null, 9000);
        serverChannel.socket().bind(listenAddr);
        serverChannel.register(proxySelector, SelectionKey.OP_ACCEPT);

        ServerSocketChannel serverChannel2 = ServerSocketChannel.open();
        serverChannel2.configureBlocking(false);

        InetSocketAddress listenAddr2 = new InetSocketAddress((InetAddress)null, 9001);
        serverChannel2.socket().bind(listenAddr2);
        serverChannel2.register(proxySelector, SelectionKey.OP_ACCEPT);

        portMap.put(9000, 8084);
        portMap.put(9001, 8085);
        try
        {
            // processing
            while (true) {
                // wait for events
                proxySelector.select();

                // wakeup to work on selected keys
                Iterator keys = proxySelector.selectedKeys().iterator();
                while (keys.hasNext()) {
                    SelectionKey key = (SelectionKey) keys.next();

                    if (! key.isValid()) {
                        continue;
                    }

                    // this is necessary to prevent the same key from coming up
                    // again the next time around.
                    keys.remove();

                    if (key.isAcceptable()) {
                        accept(key);
                    }
                    else if(key.isConnectable())
                    {
                        connect(key);
                    }
                    else if (key.isReadable()) {
                        read(key);
                    }
                    else if (key.isWritable()) {
                        write(key);
                    }
                }
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

}

job waiter/workers [boost based]

Wed, 22 Aug 2012 14:00:53 GMT

С недавнего времени обзавелся вот таким самописным лисапедом, делюсь может кому то пригодится:
Суть такая:
— нужно было много рабочих потоков которые обрабатывают данные для основного
— функции рабочих потоков могут иметь разные сигнатуры, так как входные данные тоже разные
— в один момент времени основной поток может обработать данные только одного рабочего потока
— основной поток получает нотификацию от рабочего когда данные для него готовы, остальные становятся в очередь

"Пример использования:"

//функция рабочего потока получает интерфейс и (jobID) через который уведомляет что работа закончилась.
//может вернуть true, если требуется ещё одна итерация или false если рабочий поток больше не нужен. 
bool  job_thread(JOB::I_job_pool_worker* p, unsigned int jobID)
{
    //это рабочий поток здесь готовим данные (что то грузим с диска/динамически генерируем и т.д.)
    //и сообщаем основному потоку что данные готовы
    void *pData = ....
    p->notify( pData ); //можно просто p->notify() - тогда в основном потоке ориентируемся на ID
    return true;
}

//функция основного потока ожидающая данные от любого рабочего потока, 
//и нотифицирующая его (по ID) что обработка данных закончена и можно продолжать работу.
void  job_waiter(JOB::I_job_pool_waiter* p)
{
    unsigned int id = -1;
    void* pData = NULL;
    
    while(p->wait(&id, &pData)) 
    //или просто while(p->wait(&id)) - если ориентируемся по ID (в id будет записан идентификатор рабочего потока от которого пришло сообщение)
    {
        //основной поток что то делает с данными
        //и после сообщает рабочему потоку что его данные успешно обработаны
        p->processed();
    }
}

int main() {
    
    //создаем pool на 45 рабочих потоков, не беда если подпишемся не на все
    const unsigned int total_job = 45; 
    JOB::job_pool    pool(total_job);
    
    for( unsigned int n = 0; n < total_job-2; ++n )
    {
      pool.subscribe_job_thread(n, boost::bind(&job_thread, _1, _2));
    }

    //функции рабочих потоков могут иметь разные сигнатуры
    int n = ...;
    pool.subscribe_job_thread(n, boost::bind(&job_thread_2, _1, _2, 10, boost::ref(n)));
    
    //запускаем наш пул
    pool.run(boost::bind(&job_waiter, _1));   

    return 0;
}

"Код класса:"

#ifndef __job_pool_h__
#define __job_pool_h__

//boost
#include "boost/function.hpp"
#include "boost/thread.hpp"
#include "boost/thread/locks.hpp"
#include "boost/function.hpp"
#include "boost/bind.hpp"
#include "boost/shared_array.hpp"
//std
#include <map>

namespace JOB {
//........................................................................
  class  I_job_pool_waiter
  {
  public:
    virtual bool  wait( unsigned int* jobID, void **user_data = NULL ) = 0;
    virtual void  processed() = 0;
  };
//........................................................................
  class  I_job_pool_worker
  {
  public:
    virtual void  notify( void* user_data = NULL ) = 0;
  };
//........................................................................
//........................................................................
  class  job_pool : public I_job_pool_waiter, public I_job_pool_worker
  {
    //interface I_job_pool_waiter
  private:
    //call when waiter ready for process job
    virtual bool  wait( unsigned int* jobID, void **user_data = NULL )
    {
      //wait for notify about data
      boost::unique_lock<boost::mutex> lock_waiter(m_mtx_waiter);
      if( active_jobs() ) 
      { //if !finish
        if(-1 == m_job_done_ID)
          m_cond_main.wait(m_mtx_waiter);

        if( -1 == m_job_done_ID ) return false;

        assert(-1 != m_job_done_ID);
        *jobID = m_job_done_ID;
        m_job_done_ID = -1;
        if(NULL != user_data) { *user_data = m_user_data; m_user_data = NULL; }

        return true;
      }

      //no job
      return false;
    }

    //call when waiter processed job
    virtual void  processed()
    {
      m_cond_main.notify_one();
    }

    //interface I_job_pool_worker
  private:
    //call when work thread want notify that job is done
    virtual void  notify( void* user_data = NULL )
    {
      //only one job thread can enter to here
      boost::lock_guard<boost::mutex> lock_guard(m_mtx_notify);

      //no any other job
      assert(-1 == m_job_done_ID && NULL == m_user_data);
      boost::unique_lock<boost::mutex> lock_waiter(m_mtx_waiter);  

      //set jobID and data
      m_job_done_ID = threadID_to_jobID(boost::this_thread::get_id());
      m_user_data = user_data;
      
      //notify to main thread that job is ready for processed and wait
      m_cond_main.notify_all();
      m_cond_main.wait(m_mtx_waiter);
    }

  public:
    job_pool(unsigned int threads_count)
      : m_connection(new connection_info[threads_count])
      , m_total_job_threads(threads_count)
      , m_job_counter(0)
      , m_job_done_ID(-1)
      , m_user_data(NULL)
    {}

    template< typename F >
    bool  subscribe_job_thread(unsigned int jobID, F work_thread_funk)
    {
      if( !is_exist_jobID(jobID) && m_job_counter > m_total_job_threads ) return false;

      unsigned int jobIDX = 0;
      if( is_exist_jobID(jobID) ) {
        //job already exist
        jobIDX = jobID_to_jobIDX(jobID);
      } else {
        //new job
        jobIDX = m_job_counter++;
      }
      
      //subscribe
      m_connection[jobIDX].m_thread_fn = work_thread_funk;
      m_map_jobID_con_info_IDX[jobID] = jobIDX;
    
      return true;
    }

    template< typename F >
    void  run(F main_thread_funk) 
    {
      create_job_threads();
      main_thread_funk((I_job_pool_waiter*)this);
      
      //wait while all threads done
      m_tg.join_all();
    }

  private:
    void  job_thread(unsigned int jobID)
    {
      register_threadID(boost::this_thread::get_id(), jobID);

      bool bContinue = true;
      while( bContinue ) 
      {
        bContinue = m_connection[jobID_to_jobIDX(jobID)].m_thread_fn((I_job_pool_worker*)this, jobID);
      }
      
      if(0 == dec_job_counter()) {
        boost::unique_lock<boost::mutex> lock_waiter(m_mtx_waiter);    
        m_cond_main.notify_all();
      }
    }

    void  create_job_threads()
    {
      for( map_uiui::const_iterator it = m_map_jobID_con_info_IDX.begin(), itE = m_map_jobID_con_info_IDX.end(); it != itE; ++it)
      {
        m_tg.create_thread(boost::bind(&job_pool::job_thread, this, (*it).first));
      }
    }

  private:
    bool  is_exist_jobID(unsigned int jobID) const
    {
      return m_map_jobID_con_info_IDX.end() != m_map_jobID_con_info_IDX.find(jobID);
    }

    unsigned int jobID_to_jobIDX(unsigned int jobID) const
    {
      map_uiui::const_iterator it = m_map_jobID_con_info_IDX.find(jobID);
      assert( m_map_jobID_con_info_IDX.end() != it );
      return (*it).second;
    }

    unsigned int threadID_to_jobID(boost::thread::id threadID) const
    {
      map_thID_ui::const_iterator it = m_map_ThreadID_to_jobID.find(threadID);
      assert( m_map_ThreadID_to_jobID.end() != it );
      return (*it).second;
    }

    void  register_threadID(boost::thread::id threadID, unsigned int jobID)
    {
      boost::lock_guard<boost::mutex> lock(m_mtx_rc);
      m_map_ThreadID_to_jobID[threadID] = jobID;
    }

    unsigned int active_jobs() {
      boost::lock_guard<boost::mutex> lock(m_mtx_counter);
      return m_job_counter;
    }

    unsigned int dec_job_counter() {
      boost::lock_guard<boost::mutex> lock(m_mtx_counter);
      return --m_job_counter;
    }

  private:
    typedef boost::function<bool(I_job_pool_worker*, unsigned int)> job_worker_fn;

    struct  connection_info 
    {
      job_worker_fn      m_thread_fn;
    };

    typedef boost::shared_array<connection_info> sh_a_connections;
    typedef std::map<unsigned int, unsigned int> map_uiui;
    typedef std::map<boost::thread::id, unsigned int>   map_thID_ui;

    map_uiui      m_map_jobID_con_info_IDX;
    map_thID_ui      m_map_ThreadID_to_jobID;
    sh_a_connections  m_connection;

  private:
    const unsigned int    m_total_job_threads;
    volatile unsigned    m_job_counter;
    volatile unsigned int  m_job_done_ID;
    void*          m_user_data;

    boost::thread_group        m_tg;
    boost::condition_variable_any  m_cond_main;
    boost::mutex          m_mtx_waiter;
    boost::mutex          m_mtx_counter;
    boost::mutex          m_mtx_notify;
    boost::mutex          m_mtx_rc;
  };
} //JOB ns

#endif

statusLine

Thu, 21 Jun 2012 15:50:34 GMT

Сделал все по примеру, метод
public void HelloWorld()
{
MessageBox.Show("Hello World!");
statusLine.SetStatusLine("Yoyoyo");
}
из 1с вызывается, MessageBox показывает. Но на строчку
statusLine.SetStatusLine("Yoyoyo");
ругается, говорит, что в ней NullReferenceException. Интерфейс IInitDone имплементировал.
То же самое при обращении к методам asyncEvent.
public void Done() { }
public void GetInfo([MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_VARIANT)]
ref object[] info)
{
info[0] = 2000;
}
/// <summary>
/// Инициализация компонента
/// </summary>
/// <param name="connection">reference to IDispatch</param>
public void Init([MarshalAs(UnmanagedType.IDispatch)]
object connection)
{
asyncEvent = (IAsyncEvent)connection;
statusLine = (IStatusLine)connection;
}
Подскажите, в чем дело?

Подсчет строк кода (и не только) с отчетом в IE (vbscript)

Thu, 03 May 2012 08:37:46 GMT

Использование:
1) Помещаем код в vbs файл, например linescounter.vbs
2) Выделяем в папке интересующие файлы (любого типа, не обязательно сорсы) и переносим на файл скрипта. Появится IE с таблицей отчета
2) В коде булевый параметр skipEmpty задает игнорирование пустых строк (определяется через Trim; по умолчанию 0)

' VB Script Document
option explicit

Const thisScriptName = "linescounter.vbs"

Const ForReading = 1

'если запускаем скрипт автономно
if WScript.ScriptName = thisScriptName then
    if WScript.Arguments.Count > 0  then        
        Dim cb
        set cb = new FindFileCallback

        Dim fname
        Dim res
        for each fname in WScript.Arguments
            res = cb.Found(fname)
            If res(0) <> 0 Then    
                Msgbox Join(res, vbCrLf), vbCritical, "Ошибка в " & thisScriptName 
            End If
        next
        
        set cb = nothing    
    else
        WScript.Echo "Формат вызова: " & thisScriptName & " " & "{имя файла}"
    end if         
end if
    
'Данный интерфейс предоставляет callback функцию для FindFile
class FindFileCallback
    Public skipEmpty
    Private fso
    Private table
    Private filesCount
    Private linesTotal

    Private Sub Class_Initialize() 
        skipEmpty = 0
        linesTotal = 0
        set fso = CreateObject("Scripting.FileSystemObject")
        
        set table = new TableBuilder
        table.ColumnsCount = 4

        table.AddCell "Номер"
        table.AddCell "Имя"
        table.AddCell "Папка"
        table.AddCell "Количество строк"                
    End Sub

    Private Sub Class_Terminate()        
        table.AddCell "Всего строк"
        table.AddCell linesTotal
                            
        set fso = Nothing
        set table = Nothing
    End Sub

    'Данная функция будет вызываться в процессе работы FindFile::Find() для каждого найденного файла
    Public Function Found(fname)
        On Error resume next
        
        filesCount = filesCount + 1

        Dim fp
        set fp = fso.OpenTextFile(fname, ForReading, False)
    
        Dim s
        DIm linesCounter
        do while not (fp.atEndOfStream)
            s = fp.ReadLine
            if (not CBool(skipEmpty)) or (CBool(skipEmpty) and Trim(s) <> "") then 
                linesCounter = linesCounter + 1
            end if                
        loop
        
        fp.Close
         
        table.AddCell filesCount  
        table.AddCell "<a href = """ & fname & """> " & fso.GetFileName(fname) & "</a><br>"        

        Dim dir
        dir = fso.GetParentFolderName(fname)         
        table.AddCell "<a href = """ & dir & """> " & dir & "</a><br>"

        table.AddCell linesCounter            

        linesTotal = linesTotal + linesCounter
                            
        if Err.Number = 0 then
            Found = Array(0, "", "")
        else
            Found = Array(Err.Number, Err.Source, Err.Description)
            Err.Clear
        end if                                       
    end function    
end class

class TableBuilder
    Private oIE
    Private doc
    Private nCols
    Private iCol

    Private Sub Class_Initialize() 
        Set oIE = CreateObject("InternetExplorer.Application")                 
        
        oIE.Navigate "about:blank"   
        oIE.Visible = 1 

        Do While (oIE.Busy)
            WScript.Sleep 200
        Loop

        Set doc = oIE.Document
        doc.open
        doc.WriteLn "<html><head><title></title></head>" 
        doc.WriteLn "<body>"
        
        doc.WriteLn "<table align = left border = 0 cellspacing = 10>"
        
        nCols = 1
    End Sub

    Private Sub Class_Terminate()        
        doc.WriteLn "</table>"
        doc.WriteLn "</body></html>"
        doc.Close
        set oIE = nothing
    End Sub
        
    Public property Let ColumnsCount(val)
        if val > 0 then
            nCols = val
        else
            nCols = 1
        end if                 
    end property
    
    Public Sub AddCell(cellBody)
        if iCol = 0 then
            doc.WriteLn "<tr>"
        end if
                        
        doc.WriteLn "<td>"
        doc.WriteLn CStr(cellBody)
        doc.WriteLn "</td>"        

        iCol = iCol + 1

        if iCol = nCols then
            doc.WriteLn "</tr>"
            iCol = 0
        end if                
    end sub
end class

Библиотека реализующая ThreadLocal

Fri, 13 Apr 2012 00:24:31 GMT

Покритикуйте имплементацию обёртки для thread local объектов:
+ tls а не эмулятор, со всеми вытекающими
+ простая имплементация
+ проблем мало, и они декларированны
+ работает

ThreadLocal.h

#include "windows.h"
class ThreadLocalBase
{
public:
    virtual void DestructThreadLocalInstance() = 0;
    void * GetValue()
    {
        return TlsGetValue(GetIndex());
    }
    void SetValue(void * val)
    {
        TlsSetValue(GetIndex(), val);
    }
    DWORD GetIndex()
    {
        return m_tlsIndex;
    }
protected:
    DWORD m_tlsIndex;
    ~ThreadLocalBase(){}
};

DWORD AddAtThreadExit(ThreadLocalBase *);
void RemoveAtThreadExit(ThreadLocalBase *);

template<typename T>
class ThreadLocal : protected ThreadLocalBase
{
public:
    ThreadLocal()
    {
        m_tlsIndex = AddAtThreadExit(this);
    }    
    ~ThreadLocal()
    {
                ThreadLocal::DestructThreadLocalInstance();
        RemoveAtThreadExit(this);
    }    
    T * operator->()
    {        
        return &(**this);
    }
    T& operator*()
    {
        T *  val = (T*)GetValue();
        if (!val) 
        {
            val = new T();
            SetValue(val);
        }
        return *val;
    }
private:
    virtual void DestructThreadLocalInstance() override
    {
        void * val = GetValue();
        if (val)
        {
            delete (T*)val;
            SetValue((void*)0);
        }
    }
};

ThreadLocal.cpp

#include "ThreadAtExit.h"
#include <set>

volatile long mutex = 0;
struct lock
{
    lock() { while (InterlockedExchange(&mutex, 1) == 1) SwitchToThread();}
    ~lock() { InterlockedExchange(&mutex, 0);}
};
std::set<ThreadLocalBase *> AtExitSet;
DWORD AddAtThreadExit(ThreadLocalBase * tlb)
{
    lock _;
    AtExitSet.insert(tlb);
    return TlsAlloc();
}
void RemoveAtThreadExit(ThreadLocalBase * tlb)
{
    lock _;
    AtExitSet.erase(tlb);
    TlsFree(tlb->GetIndex());
}
void DestructThreadLocals()
{
    lock _;
    for(std::set<ThreadLocalBase *>::iterator it = AtExitSet.begin(), it_end =  AtExitSet.end();
        it != it_end;
        ++it)
    {
        (*it)->DestructThreadLocalInstance();
    }
}

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
    case DLL_THREAD_ATTACH:
        break;
    case DLL_THREAD_DETACH:
        DestructThreadLocals();
        break;
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

	ThreadLocal.def
	`LIBRARY ThreadLocal EXPORTS AddAtThreadExit @1 RemoveAtThreadExit @2`

Сразу оговорюсь, что это не продакшен код, а всего лиш собранная на коленке и доведённая до состояния стояния идея, решающая возможно основную, но относительно узкую задачу.
Соответственно, самодельный спин мютекс логично заменить чем-то принятым на месте работы, а имена функций, классов и переменных подогнать под местные конвенции.

О недостатках:
1. Не достаточно настраевоемо
2. Windows specific
3. Требует дополнительный Dll
4. Не работает с Delay Load (в деструкторе вызывается экспортируемая функция)
5. Выгрузка бинарника со статиком приводит к потере объекта для каждого из построивших себе инстанс оставшихся потоков.

Моё мнение об этих недостатках:
1. можно расширить по мере надобности
2. увы (если идея ясна, то не сложно переписать на pthread)
3. в большинстве случаев не проблема
4. По большому счёту, нет такой нужды
5. В подавляющем большинстве случаев магии выгрузки библиотек нет, и проблем с этим связанных решать не надо.