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

C# API для Google Voice

Sun, 22 Jan 2012 10:47:09 GMT

Не знал, в какой форум написать... Наверно сюда. Не бейте, если что.

Мы написали API для гугл-войс (C#).
Open-source есесено.
Если кому понадобится — то вот оно https://bitbucket.org/jitbit/sharpgooglevoice/wiki/Home
Не счотите за рекламу.

24.01.12 08:39: Перенесено модератором из '.NET' — TK

Reinforcement Learning Library

Tue, 04 Oct 2011 09:31:07 GMT

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

https://github.com/downloads/tarasko/rll/rll-0.1.tar.bz2
https://github.com/downloads/tarasko/rll/rll-0.1.7z

Те кто хотя бы отдалённо знаком с этой темой, попробуйте качнуть и собрать. Там есть несколько простеньких примеров. Буду очень благодарен за отзывы.
Поскольку С++11, то собирать надо либо msvs 10 либо gcc >= 4.5.2
Заранее спасибо.

Macro recorder

Fri, 12 Aug 2011 12:46:06 GMT

Macro recorder
Прога тестировалась минимально, проверок на ошибки почти нет, так что глюки не исключены.

Должен быть установлен Python 2.6 и PyWin32, затем нужно скопировать pyHook.pth и папку pyHook в site-packages.

Формат макросов в текстовом виде должен быть понятен из macros.txt. Могу заметить только, что есть два режима ввода нажатых клавиш: "сырой" — <r+>, когда можно вводить только отображаемые клавиши и "обычный" — <r-> (по умолчанию), когда можно вводить все, но с пробелами между ними. Пример:

<Name>for (Python)
<Shortcut>ctrl+alt+f
<Events><r+>for i in range():<r-> enter tab

<Name>print (Python)
<Shortcut>ctrl+alt+p
<Events><r+>print("<r->ctrl+v : " , ctrl+v )

Ввод нового макроса можно выполнить в текстовом виде, а можно с помощью хука:
ctrl+alt+F1 ShortcutKeys ctrl+alt+F2 MacroKeys ctrl+alt+F3.

Re: Kernel: Загрузка DLL из памяти (x86)

Fri, 05 Aug 2011 11:28:15 GMT

Все же с LdrProcessRelocations есть проблемы.
На некоторых длл(с огромным сайзом RelocDirectory, напр. 2FXXX) крэшится, причем uRelocsSize уже почти доходит до нуля, т.е. в районе 0X100.
Это раз. А два, не кажется ли, что баг в вечном цикле, если pRelocBlock -> SizeOfBlock в общей сумме будет не равен uRelocsSize ? (Это уже другой вопрос, почемуу не равен, но uRelocsSize типа ULONG, он то всегда больше равен нулю)

PDL: метод Destroy

Wed, 06 Jul 2011 06:49:22 GMT

Добрый день!

Вы писали:

Представим себе, что плагин собран компилятором A, а основная программа, использующая его – компилятором B. Если мы загружаем класс из плагина, его экземпляр создаётся кодом, сгенерированным компилятором A. И если мы попытаемся удалить этот экземпляр из кода основной программы просто вызвав деструктор, то удалить его попытается код, сгенерированный компиляторов B. ... Чтобы избежать подобных проблем, деструктор ~DynamicClass() сделан защищённым, а вместо него следует вызывать метод DynamicClass::Destroy(). Это метод гарантирует, что память выделяется и освобождается из одной и той же кучи.

При этом

сlass DynamicClass
{
public:
  void Destroy() throw() { delete this; }
  ...
protected:
  virtual ~DynamicClass() throw() {;; }
};

Но ведь реализация такого метода Destroy() будет в коде основной программы, оттуда он вызывается и вызов delete будет происходит тоже из нее, то есть как если бы мы прямо использовали delete plugin в коде основной программы.
Мне кажется должно быть так:

сlass DynamicClass
{
public:
  virtual void Destroy() = 0;
  ...
};

сlass MyPlugin : public DynamicClass
{
public:
  virtual void Destroy() { delete this; }
  ...
};

Если я не прав, то поясните подробнее пожалуйста.

Компаратор

Mon, 27 Jun 2011 17:40:48 GMT

Довольно часто приходится передавать IComparer<> в разные методы.
Для пользовательских классов приходится создавать класс, наследовать и т.п., да еще и хранить ссылку на экземпляр отдельно
чтобы то и дело не было создания.
Когда намного проще было бы написать лямбду "на месте".
Написал такой класс:

    public class CustomComparer<T> : IComparer<T>
    {
        private readonly Func<T, T, int> comparer;
        
        private static CustomComparer<T> instance;

        public int Compare(T x, T y)
        {
           return comparer(x, y);
        }

        public CustomComparer(Func<T,T,int> comparer)
        {
            this.comparer = comparer;
        }

        static CustomComparer<T> Create(Func<T,T,int> comparer)
        {
            return instance ?? (instance = new CustomComparer<T>(comparer));
        }
    }

юзать типа так:

CustomComparer<Lalala>.Create((l1, l2) => ...);

Думаю все понятно без комментариев.
Теперь вопрос: тыкните меня в стандартное решение из BCL, свой велосипед конечно самый крутой всегда, но все же я предпочитаю использовать стандартное апи. Или каждый сaм этот лесопед пишет?

28.06.11 19:52: Перенесено модератором из '.NET' — TK

расширяем BOOST::preprocessor

Thu, 16 Jun 2011 13:23:25 GMT

Предлагаю тут делиться недостающими в работе решениями для boost::preprocessor. Начну с себя:

1) SWITCH на препроцессоре:

"Code"

"Example"

Недостатки. Нету обработки для DEFAULT. Её теоретически сделать не сложно. Но есть проблемы с варнингами. Подробности тут

2) Раширяем возможности BOOST_PP_SEQ_ENUM что бы перечисление можно было сделать не только через запятую:

"Code"

"Example"

3) Вот ещё отличный макрос от Vian [C++] Boost_1_34_1.Preprocessor/Update (BOOST_PP_MACRO_IF/BOOST_PP_MACRO_IIF)
Пример использования

nameof.Property

Mon, 30 May 2011 13:30:04 GMT

Добрый день, господа.

Хочу поделится классом, который я использую для типобезопасного взятия имени свойства.

Для чего это нужно.
Основные области пременеия это выстрел события INotifyPropertyChanged.PropertyChanged и автоматические тесты.

Чем лучше строковых переменных?
Первое, но не главное — не ошибиться в написании имени свойства.
Второе и главное, при изменении имени свойства с помощью автоматического рефакторинга, не надо заботиться об соответствующем изменении строковых переменных.

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

Есть два способа взять имя свойства
1. Когда есть только тип, имя свойства которого надо взять.

nameof<Type>.Property( x => x.Property );

2. Когда есть переменная нужного типа.

nameof.Property( () => variable.Property );

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

INotifyPropertyChanged — второй способ, есть переменная this.

  class Presenter : INotifyPropertyChanged
  {
    private int _megaProperty;

    public int MegaProperty
    {
      get { return _megaProperty; }
      set
      {
        _megaProperty = value;
        RaisePropertyChanged( nameof.Property(() => MegaProperty) );
      }
    }

    private void RaisePropertyChanged(string propertyName)
    {
      PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }

    public event PropertyChangedEventHandler PropertyChanged;
  }

В тестах (приведены тесты nunit) используются оба

1.

Assert.That(presenter.Items, Is.All.Property( nameof<NodeType>.Property(x => x.Name) ).StartsWith("123"));
Assert.That(nodes, Is.Ordered.By( nameof<NodeType>.Property(n => n.Name) ));

eventExpectator.AssertWasCalled(h => h.Invoke(Arg<object>.Is.Anything, Arg<PropertyChangedEventArgs>.Matches(args =>
   args.PropertyName == nameof.Property(() => presenter.Items))), null);

Собственно код классов

  public static class nameof
  {
    public static string Property< TV >( Expression< Func< TV > > property )
    {
      var body = property.Body as MemberExpression;
        if(body == null)
            throw new ArgumentException("'expression' should be a member expression");
        return body.Member.Name;
    }
  }

  public static class nameof< T >
  {
    public static string Property< TV >( Expression< Func< T, TV > > property )
    {
       var body = property.Body as MemberExpression;
        if(body == null)
            throw new ArgumentException("'expression' should be a member expression");
        return body.Member.Name;
    }
  }

надеюсь кому-нибудь пригодится

Ed.ward

31.05.11 11:30: Перенесено из '.NET'

Управление сетью

Fri, 20 May 2011 09:54:10 GMT

Что делать с программой?

http://sysadminblog.ru/sydkit/2010/06/03/upravlenie-it-infrastrukturoy-i-ee-monitoring-delaem-po-sami.html

Ранее я уже писал о своем проекте подвисшем на уровне беты. Попробую выложить бету для тестирования, разного рода пожелания, багрепорты, советы и прочее крайне приветствуется.
Прогу назвал SyDkit (от SysaDminkit), предназначается для управления сетевой инфраструктурой малый и средних организаций.
Возможности программы:
— Мониторинг мониторинг сетевых устройств. Пока используется только ping, доступность портов по tcp добавлю позже;
— Скриптовый движок для выполнения рутинных операций, например резервного копирования конфига с cisco или автоматического логина на любой девайс;
— Встроенный telnet клиент. Пока притормаживает, но разберусь в чем дело;
— Встроенные утилиты ping, tracert, whois, lancalc собственной разработки;
— Возможность подключения к девайсу в 2 клика по заранее настроенному сценарию подключения;
— Хранение неограниченного количества схем, возможность быстрого перехода между ними;
— Снятие статистики по SNMP, пока заготовленный набор параметров, позже добавлю самостоятельную настройку;
— Хранение RDP сценариев входа на сервера;
— Встроенный TFTP клиент с раскладыванием полученных файлов от девайсов по папкам;

Есть тут советчики?

Кросплатформенный вариант string2int

Fri, 29 Apr 2011 07:30:27 GMT

Вот еще один вариант в тему сабжа без atoi и strtol

int val =0 ;
std::istringstream i_str(index.c_str());
i_str >> val;

[C#] Natural string comparison

Tue, 12 Apr 2011 23:19:39 GMT

Погуглил немного готовые реализации — ужас какие неэффективные! Пришлось набросать свою, там всего-то пара строк кода, но вдруг кому-то пригодится.

[TestFixture]
public class NaturalComparerTest
{
   readonly NaturalComparer cmp = new NaturalComparer();

   [Test]
   [TestCase(null, "")]
   [TestCase("", "a")]
   [TestCase("a", "aa")]
   [TestCase("3", "4")]
   [TestCase("3", "34")]
   [TestCase("3", "a")]
   [TestCase("a3", "a4")]
   [TestCase("a3", "b3")]
   [TestCase("a34", "a34b")]
   [TestCase("AK47", "AK74")]
   [TestCase("I-9", "I-10")]
   [TestCase("5-out-of-8", "5-out-of-20")]
   [TestCase("5-out-of-8-apples", "5-out-of-20-apples")]
   [TestCase("episode-1-part-1", "episode-1-part-2")]
   public void TestLess(string x, string y)
   {
      Assert.IsTrue(cmp.Compare(x, y) < 0);
   }

   [Test]
   [TestCase(null, null)]
   [TestCase("", "")]
   [TestCase("a", "a")]
   [TestCase("4", "4")]
   [TestCase("43", "43")]
   [TestCase("a-43", "a-43")]
   [TestCase("43-a-34", "43-a-34")]
   public void TestEqual(string x, string y)
   {
      Assert.AreEqual(0, cmp.Compare(x, y));
   }
}


public class NaturalComparer : IComparer<string>
{
   public int Compare(string x, string y)
   {
      if (x == null && y == null) return 0;
      if (x == null) return -1;
      if (y == null) return 1;

      int lx = x.Length, ly = y.Length;

      for (int mx = 0, my = 0; mx < lx && my < ly; mx++, my++)
      {
         if (char.IsDigit(x[mx]) && char.IsDigit(y[my]))
         {
            long vx = 0, vy = 0;

            for (; mx < lx && char.IsDigit(x[mx]); mx++)
               vx = vx * 10 + x[mx] - '0';

            for (; my < ly && char.IsDigit(y[my]); my++)
               vy = vy * 10 + y[my] - '0';

            if (vx != vy)
               return vx > vy ? 1 : -1;
         }

         if (mx < lx && my < ly && x[mx] != y[my])
            return x[mx] > y[my] ? 1 : -1;
      }

      return lx - ly;
   }
}

Tuple для C++

Sat, 02 Apr 2011 09:34:52 GMT

Вчера совершенно случайно начали обсуждать tuple и их реализацию в С++, может они шутили, но я занялся и вот что получилось.

// MSV Lib. Tuple. 2011.04.01 21:60

#define TPLM Tuple(TPLMOVE) + 
#define TPLC Tuple(TPLCOPY) + 
#define TPL Tuple() + 
//#define GTPL Tuple() +
#define TPLERROR(t) { memcpy(0, 0, 1); }

#define TPLMOVE    1 // copy to tuple, memset 0 original. = destruct dest, copy to dest.
#define TPLCOPY    2 // copy constructor = destruct dest, copy to dest
#define TPLGET    3 // destruct all values :)

#include <memory.h>
#include <math.h>
#include <stdio.h>
#include <typeinfo>
#include <string.h>

#define max(a, b) (((a) > (b)) ? (a) : (b))
#define min(a, b) (((a) < (b)) ? (a) : (b))

unsigned int mcrc(char* name, unsigned int sz){
    unsigned int ret=0; if(!sz) sz=(unsigned int)strlen(name);
    char*t=name+sz; int p=0;
    while(name<t){
        *(((char*)&ret)+p)+=*name; p++;
        if(p>=4) p=0; name++;
    }
return ret;
}

struct Tupled{ unsigned int sz, type; void *v; char data[0]; };

class Tuple{
    int count, set, dusz, dasz;
    unsigned char *data;
    int type; int adel; 

public:
    Tuple(){ count=0; set=0; type=0; dusz=0; dasz=0; data=0; adel=0; }
    Tuple(int t){ type=t; }

    ~Tuple(){ if(count!=set) TPLERROR("~Tuple"); delete data; }

    Tuple(Tuple &t){
        count=t.count; set=t.set; dusz=t.dusz; dasz=t.dasz; data=t.data;
        t.count=0; t.set=0; t.data=0; adel=1;
    }

    template <class T>
    Tuple& operator+(T &t){ if(!adel) Add(&t, sizeof(t), t); else Del(&t, sizeof(t), t); return *this; }
    template <class T>
    Tuple& operator-(T &t){ if(!adel) Add(&t, sizeof(t), t); else Del(&t, sizeof(t), t); return *this; }
    template <class T>
    Tuple& operator*(T &t){ if(!adel) Add(&t, sizeof(t), t); else Del(&t, sizeof(t), t); return *this; }
    template <class T>
    Tuple& operator/(T &t){ if(!adel) Add(&t, sizeof(t), t); else Del(&t, sizeof(t), t); return *this; }
    template <class T>
    Tuple& operator,(T &t){ if(!adel) Add(&t, sizeof(t), t); else Del(&t, sizeof(t), t); return *this; }
    template <class T>
    Tuple& operator>(T &t){ if(!adel) Add(&t, sizeof(t), t); else Del(&t, sizeof(t), t); return *this; }
    template <class T>
    Tuple& operator <(T &t){ if(!adel) Add(&t, sizeof(t), t); else Del(&t, sizeof(t), t); return *this; }

    template <class T>
    void Add(void *v, int s, T &t){
        if(dasz-dusz<s+4+(int)sizeof(void*)){
            unsigned char *ldata=data;
            data=new unsigned char[dasz+max(128, s+4)];
            memcpy(data, ldata, dasz);
            dasz+=max(128, s);                    
            delete [] ldata;
        }
        Tupled &d=*(Tupled*)(data+dusz);
        d.sz=s;
        memcpy(&d.v, v, sizeof(void*));
        if(type==TPLCOPY){ *(T*)d.data=t; } else memcpy(d.data, v, s);
        if(type==TPLMOVE) t.~T();

        d.type=mcrc((char*)typeid(t).name(), 0);
        dusz+=sizeof(Tupled)+s; count++;
    }

    template <class T>
    void Del(void *v, int s, T &t){
        if(set>=count){ TPLERROR("Tuple::Set"); return ; }
        unsigned char *p=GetData(set);
        if(!p){ TPLERROR("Tuple::NoData"); return ; }

        Tupled &d=*(Tupled*)p;
        unsigned int tp=mcrc((char*)typeid(t).name(), 0);
        if(tp!=d.type){ TPLERROR("Tuple::TYPE"); return ;}

        t.~T();
        if(d.sz!=s){ TPLERROR("Tuple::SIZE"); return ;}
        memcpy(v, d.data, d.sz);
        
        set++;
    }

    unsigned char* GetData(int c){
        if(c>=count) return 0;
        unsigned char *p=data;
        for(int i=0; i<c; i++){
            p+=sizeof(Tupled)+*(int*)p;
        }
        return p;
    }
};

Tuple T(){ int i=1, j=2, k=3; return TPL i, j, k; }
int T2(Tuple t){
    int a, b, c;
    t, a, b, c;
    printf(" T2: %d %d %d", a, b, c);
    return 1;
}

int main(){
    int a, b, c;
    T(), a, b, c;
    printf("%d %d %d", a, b, c);
    T2(TPL a + b + c);
    return 0;
}

Код можно скачать здесь:
http://source.centerix.ru/source/msv/Tuples/Tuples.cpp
ftp://source:source@source.centerix.ru/source/msv/Tuples/Tuples.cpp

Простенько и со вкусом. Без кучи шаблонов. Так как я видел это в D.
Создать Typle не проблема, сложнее оказалось сделать их использование достаточно простым.
В итоге получилось сделать даже проще, чем я мог предполагать. Хватило одного класса.
В принципе, переменные в списке можно разделять любым знаком TPL a , b + c — d * e / f < g > h; но думаю лучше оставить одну запятую, хотя практика показывает, что этого мало.
Единственный минус, это переменные после вызова функции: T(), a, b... К сожалению перед функцией так и не получилось сделать. при использовании +-*/<> переменные выполняли эти операции раньше. При разделении запятыми переменные вообще исчезали. В общем, против направления выполнения не попрешь.

Контроль за количеством переменных и типами оставляю на программиста, если он ошибется вызывается memcpy(0, 0, 1); мне показалось это достаточно прямолинейное сообщение об ошибке. Можно сделать что-нибудь попроще.

Таким же способом можно передавать туплы в функции. Запятые не прошли, пришлось использовать знаки +.

Хотелось бы узнать, есть ли еще реализации туплов. Про туплы на boost слышал. Мне не понравилось. Там каждый шаг нужно описывать.
Хотелось бы узнать, есть ли желающие использовать мою разработку. Я не знаю, буду ли использовать ее, или более привычное получение результатов через адреса int &i. Я обычно стремлюсь к оптимизации, int &i быстрее. Хотя тут действительно небольшие потери в скорости.

Разработка еще не закончена. Есть еще пара идей по ускорению. Если будут пожелание по расширению функционала, можно рассмотреть.

Ошибка в aes.hpp и aes.cpp

Tue, 29 Mar 2011 09:14:46 GMT

Есть такая тема [C++] Advanced Encryption Standard (Rijndael).

В ней выложены исходники. При первом задании ключа происходит построение статических таблиц! Поэтому параллельно из нескольких потоков такую реализацию использоваться нельзя (речь идет об отдельном экземпляре, а не о параллельном доступе)!

Если вы хотите использовать шифрование в нескольких потоках одновременно, необходимо функцию init_tables() вынести в public и сделать статиком, а проверку

if( ! s_box[0] ) init_tables();

убрать из cpp.

Теперь вначале программы вызывайте aes::init_tables() и можете использовать реализации aes в нескольких потоках.

PS. К сожалению тема закрыта для комментариев, пришлось отдельную делать.

WR mutex под винду 2003-

Sun, 27 Mar 2011 13:51:14 GMT

Потестировав известные реализации RW мютексов пришел к мнению, что они мягко говоря не идеальны. И по тому как они работают в экстремальных условиях стало ясно, что распределение приоритетов там не всегда логично.
Наконец реализовав то, что по моему мнению является идеальным дизайном я провёл несколько тестов.
i7 Win7 release, итерации за 2 секунды работы всреднем.
Для начала циферки:
Впустую:

	Скрытый текст
	Читающих/Пишущих: потоков — 1/1; SRWLOCK Writer: 17571850 [12849582..25373812] Reader: 22811587 [20543874..25737670] Мой Writer: 473317 [449095..504612] Reader: 583480 [540999..610374] Другая Хорошая реализация Writer: 964481 [930885..987693] Reader: 951201 [915743..979739] Читающих/Пишущих: потоков — 10/10; SRWLOCK Writer: 10186292 [8993933..11335822] Reader: 20073894 [19296720..20842069] Мой Writer: 243614 [237284..248490] Reader: 2435974 [2372662..2484779] Другая Хорошая реализация Writer: 690732 [678387..704493] Reader: 387787 [281092..668993] Читающих/Пишущих: потоков — 100/100; SRWLOCK Writer: 12488187 [11040251..14616537] Reader: 19373003 [17787928..21342143] Мой Writer: 45493 [44475..46775] Reader: 4549319 [4447461..4677469] Другая Хорошая реализация Writer: 673611 [658899..685033] Reader: 488324 [355513..912665] Читающих/Пишущих: потоков — 1/100; SRWLOCK Writer: 40579876 [35215349..43018115] Reader: 294583 [228763..357757] Мой Writer: 426384 [398431..449591] Reader: 425354 [398366..448124] Другая Хорошая реализация Writer: 948498 [918588..999534] Reader: 5865 [4611..7837] Читающих/Пишущих: потоков — 10/100; SRWLOCK Writer: 37609876 [32402064..40220011] Reader: 3568099 [2817836..4689182] Мой Writer: 232870 [216410..244184] Reader: 2328580 [2163973..2441728] Другая Хорошая реализация Writer: 918922 [902664..931336] Reader: 59024 [49551..70554] Читающих/Пишущих: потоков — 100/10; SRWLOCK Writer: 94095 [32351..166210] Reader: 25208319 [22283416..29773294] Мой Writer: 46237 [45409..46873] Reader: 4623669 [4540849..4687261] Другая Хорошая реализация Writer: 360381 [276161..421879] Reader: 2155818 [1422410..3113057] Читающих/Пишущих: потоков — 100/1; SRWLOCK Writer: 3171 [1131..10341] Reader: 25676035 [22933782..30288583] Мой Writer: 5649 [5150..6161] Reader: 19515644 [18671401..23383889] Другая Хорошая реализация Writer: 114752 [59787..151780] Reader: 4626576 [4242130..5223980]

С работой пишущих Sleep(10):

	Скрытый текст
	Читающих/Пишущих: потоков — 1/1; SRWLOCK Writer: 200 [199..201] Reader: 2886 [0..21443] Мой Writer: 200 [200..201] Reader: 200 [200..201] Другая Хорошая реализация Writer: 200 [200..201] Reader: 2236 [413..6963] Читающих/Пишущих: потоков — 10/10; SRWLOCK Writer: 195 [194..198] Reader: 855739 [408601..1235543] Мой Writer: 200 [200..201] Reader: 2001 [2000..2010] Другая Хорошая реализация Writer: 200 [200..201] Reader: 5583 [3415..8839] Читающих/Пишущих: потоков — 100/100; SRWLOCK Writer: 197 [190..200] Reader: 829675 [487839..1542292] Мой Writer: 200 [200..201] Reader: 20010 [20000..20100] Другая Хорошая реализация Writer: 200 [200..201] Reader: 4627 [3233..5839] Читающих/Пишущих: потоков — 1/100; SRWLOCK Writer: 200 [199..201] Reader: 245202 [151070..385725] Мой Writer: 200 [200..201] Reader: 200 [200..201] Другая Хорошая реализация Writer: 200 [200..201] Reader: 114 [34..264] Читающих/Пишущих: потоков — 10/100; SRWLOCK Writer: 200 [200..200] Reader: 297851 [242640..383785] Мой Writer: 200 [199..201] Reader: 2000 [1990..2010] Другая Хорошая реализация Writer: 200 [200..201] Reader: 742 [613..1066] Читающих/Пишущих: потоков — 100/10; SRWLOCK Writer: 146 [128..184] Reader: 6282265 [2130911..8406613] Мой Writer: 200 [200..200] Reader: 20000 [20000..20000] Другая Хорошая реализация Writer: 199 [199..200] Reader: 51798 [41332..71292] Читающих/Пишущих: потоков — 100/1; SRWLOCK Writer: 33 [7..110] Reader: 20526658 [10612527..23590723] Мой Writer: 185 [126..200] Reader: 1615123 [47649..8006288] Другая Хорошая реализация Writer: 188 [187..193] Reader: 429406 [368932..502070]

Ниже приведён код моего мютекса, для удобства разделённого на несколько частей.
Это компилируемый код, однако не организован в классы. С-style интерфейс.

Defines

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

Exclusive Lock

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

Shared Lock

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

Exclusive Release

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

Shared Release

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

Другая хорошая реализация. Выбрал именно эту, так как она рабочая и не приводит к голоданию в крайних случаях.

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

Выводы после Вас

make clean for Visual Studio

Wed, 16 Feb 2011 18:07:49 GMT

Иногда возникает необходимость скопировать папку проекта (Visual Studio), например, на флешку или в сетевую шару. Проблемой становятся файлы, которые нагенерировала студия: база Intellisense, логи, объектные файлы и т.п. Из простого копирования нескольких *.cpp файлов процесс может превратиться в довольно длительное ожидание или нехватку места Написал небольшую утилитку которая удаляет "лишние" файлы студии в указанной папке и подпапках. Пример использования:

.\vsgarbage D:\Projects\CPP\HelloWorld

Код утилиты:

#include <iostream>

#include <boost/filesystem.hpp>

namespace fs = boost::filesystem;

typedef std::vector<std::string> GarbageList;

GarbageList g_garbage_extensions;
const int EQUALS = 0;  // Strings are equals

void InitializeGarbageFileExtensions(GarbageList& list)
{
    list.push_back(".obj");
    list.push_back(".log");
    list.push_back(".sdf");
    list.push_back(".ipch");
    list.push_back(".idb");
    list.push_back(".pdb");
    list.push_back(".ilk");
    list.push_back(".dep");
    list.push_back(".tmp");
    list.push_back(".tlog");
    list.push_back(".lastbuildstate");
    list.push_back(".opensdf");
}

bool IsGarbage(fs::path& item)
{
    if (!fs::is_directory(item))  // Only files are checked
    {
        std::string extension = item.extension();
        for (GarbageList::iterator it = g_garbage_extensions.begin();
            it != g_garbage_extensions.end(); ++it)
        {
            std::string& current = (*it);
            if (extension.compare(current) == EQUALS)
            {
                return true;
            }
        }
    }
    return false;
}

int main(int argc, char** argv)
{    
    if (argc > 1)
    {
        char* dir = argv[1];
        std::cout << "Deleting garbage in: " << dir << std::endl;
        fs::path dir_path(dir);
        if (fs::is_directory(dir_path))
        {
            InitializeGarbageFileExtensions(g_garbage_extensions);
            fs::recursive_directory_iterator end_it;
            int items_removed = 0;
            for (fs::recursive_directory_iterator it(dir_path); it != end_it; ++it)
            {
                fs::path current(it->path());
                if (IsGarbage(current))
                {
                    fs::remove(current);
                    items_removed++;
                }
            }
            std::cout << "Items deleted: " << items_removed << std::endl;
        }
        else
        {
            std::cerr << "Error. Specified path is not a directory\n";
        }
    }
    else
    {
        std::cout << "Usage: .\\vsgarbage path_to_directory\n";
    }
    return 0;
}

Готовный бинарник можно взять в прикрепленных файлах.

Делегаты для C++

Fri, 04 Feb 2011 19:28:49 GMT

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

Выкладываю реализации делегатов TSingleDelegate и TMultiDelegate, которые использую сам. Возможно кому-то пригодится, кто любит простоту, удобство и эффективность. Код базируется на делегатах от Don Clugston, по этому, кто уже их использовал, осваивать не придется (только для VC++)

Ссылка на архив

Пример/туториал:

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

#include <vector>
#include <delegate.hpp>

///////////////////////////////////////////////////////////////////////////////

void sf3(int, int, int) { std::cout << __FUNCTION__ << "()" << std::endl; }

class A
{
public:
    void mf3(int,int,int) { std::cout << __FUNCTION__ << "()" << std::endl; }
    void cf3(int,int,int) const { std::cout << __FUNCTION__ << "() const" << std::endl; }
    static void sf3(int,int,int) { std::cout << __FUNCTION__ << "()" << std::endl; }
    virtual void vf3(int,int,int) { std::cout << __FUNCTION__ << "() virtual" << std::endl; }
    virtual void vcf3(int,int,int) const { std::cout << __FUNCTION__ << "() virtual const" << std::endl; }
};

class B : public A
{
private:
    WCHAR _buf[256];

public:
    virtual void vf3(int,int,int) { std::cout << __FUNCTION__ << "() override" << std::endl; }
    virtual void vcf3(int,int,int) const { std::cout << __FUNCTION__ << "() override const" << std::endl; }
};

///////////////////////////////////////////////////////////////////////////////

void wmain(int argc, wchar_t** args)
{
    typedef TSingleDelegate<void(int,int,int)> TSD3;
    typedef TMultiDelegate<void(int,int,int)> TMD3;
    std::vector<TSD3> sdl;
    std::vector<TMD3> mdl;

    A a;
    B b;
    const A* ac = new A();
    const B* bc = new B();

    /* TSingleDelegate - содержит единственную связь */

    /* конструкторы */
    TSD3 sd01;                            //пустой делегат, при вызове проверяется на NULL,- безопасно
    TSD3 sd02(sf3);                    //статическая функция
    TSD3 sd03 = sf3;                //статическая функция (вид сбоку)
    TSD3 sd04(&A::sf3);            //статическая функция класса
    TSD3 sd05 = &A::sf3;        //статическая функция класса (вид сбоку)
    TSD3 sd06 = &B::sf3;        //всё та же встатическая функция
    TSD3 sd07(&a, &A::mf3);    //фукнция класса
    TSD3 sd08(&a, &A::cf3); //константная функция класса
    TSD3 sd09(ac, &A::vf3); //виртуальная функция константного класса
    TSD3 sd10(&b, &B::mf3); //функция другого класса
    TSD3 sd11(bc, &B::cf3); //константная функция другого константного класса
    TSD3 sd12(bc, &B::vcf3);//перегруженная виртуальная константная функция другого константного класса
    TSD3 sd13(sd10);                //копирование из другого делегата
    TSD3 sd14 = sd12;                //копирование из другого делегата (вид сбоку)
    TSD3 sd15(sd11.GetMemFunc());    //копирование из анонимного указателя (TMemFunc)
    sd15.Clear(), sd15.Unbind();    //удаление связи

    /* связывание */
    TSD3 sd21;
    TSD3 sd22(sf3);
    TSD3 sd23; sd23.Bind(sf3);
    TSD3 sd24; sd24.Bind(&A::sf3);
    TSD3 sd25; sd25.Bind(&B::sf3);
    TSD3 sd26; sd26.Bind(&a, &A::mf3);
    TSD3 sd27; sd27.Bind(&a, &A::cf3);
    TSD3 sd28; sd28.Bind(ac, &A::vf3);
    TSD3 sd29; sd29.Bind(&b, &B::mf3);
    TSD3 sd30; sd30.Bind(bc, &B::cf3);
    TSD3 sd31; sd31.Bind(ac, &A::vcf3);
    TSD3 sd32; sd32.Bind(bc, &B::vcf3);
    TSD3 sd33; sd33.Bind(sd31.GetMemFunc());
    TSD3 sd34 = sd32;
    TSD3 sd35; sd35.SetMemFunc(sd33.GetMemFunc());

    sdl.push_back(sd01), sdl.push_back(sd02), sdl.push_back(sd03), sdl.push_back(sd04), sdl.push_back(sd05);
    sdl.push_back(sd06), sdl.push_back(sd07), sdl.push_back(sd08), sdl.push_back(sd09), sdl.push_back(sd10);
    sdl.push_back(sd11), sdl.push_back(sd12), sdl.push_back(sd13), sdl.push_back(sd14), sdl.push_back(sd15);
    sdl.push_back(sd21), sdl.push_back(sd22), sdl.push_back(sd23), sdl.push_back(sd24), sdl.push_back(sd25);
    sdl.push_back(sd26), sdl.push_back(sd27), sdl.push_back(sd28), sdl.push_back(sd29), sdl.push_back(sd30);
    sdl.push_back(sd31), sdl.push_back(sd32), sdl.push_back(sd33), sdl.push_back(sd34), sdl.push_back(sd35);

    /* вызов функций */
    for (size_t n = 0; n < sdl.size(); n++) sdl[n](1,2,3);
    std::cout << std::endl << std::endl;

    /* TMultiDelegate - содержит неограниченное кол-во связей */
    /* конструкция (аналогично TSingleDelegate) */
    TMD3 md01;
    TMD3 md02(sf3);
    TMD3 md03 = sf3;
    TMD3 md04(&A::sf3);
    TMD3 md05 = &A::sf3;
    TMD3 md06 = &B::sf3;
    TMD3 md07(&a, &A::mf3);
    TMD3 md08(&a, &A::cf3);
    TMD3 md09(ac, &A::vf3);
    TMD3 md10(&b, &B::mf3);
    TMD3 md11(bc, &B::cf3);
    TMD3 md12(bc, &B::vf3);
    TMD3 md13(md10);
    TMD3 md14(sd11.GetMemFunc());
    TMD3 md15 = md12;

    /* связывание (аналогично TSingleDelegate, только каждый метод можно связывать сколько угодно раз) */
    TMD3 md21;
    TMD3 md22(sf3);
    TMD3 md23; md23.Bind(sf3);
    TMD3 md24; md24.Bind(&A::sf3);
    TMD3 md25; md25.Bind(&B::sf3);
    TMD3 md26; md26.Bind(&a, &A::mf3);
    TMD3 md27; md27.Bind(&a, &A::cf3);
    TMD3 md28; md28.Bind(ac, &A::vf3); md28.Bind(ac, &A::vf3);
    TMD3 md29; md29.Bind(&b, &B::mf3);
    TMD3 md30; md30.Bind(bc, &B::cf3); md30.Bind(bc, &B::cf3);
    TMD3 md31; md31.Bind(ac, &A::vcf3);
    TMD3 md32; md32.Bind(bc, &B::vcf3);
    TMD3 md33; md33.Bind(sd31.GetMemFunc());
    TMD3 md34 = md32;
    TMD3 md35;

    mdl.push_back(md01), mdl.push_back(md02), mdl.push_back(md03), mdl.push_back(md04), mdl.push_back(md05);
    mdl.push_back(md06), mdl.push_back(md07), mdl.push_back(md08), mdl.push_back(md09), mdl.push_back(md10);
    mdl.push_back(md11), mdl.push_back(md12), mdl.push_back(md13), mdl.push_back(md14), mdl.push_back(md15);
    mdl.push_back(md21), mdl.push_back(md22), mdl.push_back(md23), mdl.push_back(md24), mdl.push_back(md25);
    mdl.push_back(md26), mdl.push_back(md27), mdl.push_back(md28), mdl.push_back(md29), mdl.push_back(md30);
    mdl.push_back(md31), mdl.push_back(md32), mdl.push_back(md33), mdl.push_back(md34), mdl.push_back(md35);

    /* выполнение */
    for (size_t n = 0; n < mdl.size(); n++) mdl[n](1,2,3);
    std::cout << std::endl << std::endl;

    /////////////////////////////////////////////////////////////////////////////

    TMD3 md40(md24), md41, md42;
    md40.Bind(&B::sf3);                    //связывание статической функции (можно и через оператор)
    md40 += md26, md40 += md27, md40 += md28, md40 += md31, md40 += md32;    //связывание через оператор +=
    md40 -= md25;                                //удаление через оператор -=
    md41.Bind(md40);                        //добавление всех связей из другого делегата
    md42 = md41;                                //удаление текущих, добавление всех связей из другого делегата
    md40 -= sf3;                                    //удаление статической функции через оператор -=
    md40.Unbind(ac, &A::vcf3);    //удаление метода
    md40 += sd23.GetMemFunc();    //связывание метода из TSingleDelegate через анонимный указатель (TMemFunc)
    md40 -= sd26.GetMemFunc();        //удаление метода из TSingleDelegate через анонимный указатель (TMemFunc)
    md42.Length();                            //кол-во всех связей
    md42.Clear();                                //удаление всех связей
    //Bind(); Unbind(); операторы +=, -= возвращают общее кол-во связей

    md40(1,2,3);    //вызов всех-всех связей в порядке добавления
    std::cout << std::endl;

    if (!md41.IsEmpty()) md41.Invoke(1,2,3);    //проверка на наличие связей, вызов всех связей
    std::cout << std::endl;

    md41 -= md40;                                    //удаление всех связей md40 из md41
    if (md41) md41.Invoke(1,2,3);    //проверка на наличие связей, вызов что осталось
    std::cout << std::endl;

    /* сравнение */
    if (sd11 < sd12) std::cout << "sd11 < sd12" << std::endl;
    std::cout << "sd05" << (sd05 == sd06 ? " == " : " != ") << "sd06" << std::endl;
    std::cout << "md41" << (md41 == md40 ? " == " : " != ") << "md40" << std::endl;
    std::cout << std::endl;
    
}

binary heap с возможностью изменения [C++]

Fri, 28 Jan 2011 17:52:54 GMT

Есть такие стандартные функции — std::make_heap, std::push_heap, std::pop_heap. Всё с ними здорово, но иногда возникает необходимость поменять какой-нибудь элемент в куче, не являющийся верхним. Само по себе это не сложно, но в станартной библиотеке такой функции нет. Тк что завелся такой велосипед.

Пользоваться так же, как и стандартными, только если требуется изменить элемент в куче, то после изменения вызываем update_heap.

Используется C++0x, чтобы превратить в старый добрый обычный C++ достаточно убрать все std::move.

Почему потребовалось писать свои версии make_heap, push_heap, pop_heap? Порядок элементов в куче стандартом никак не гарантируется, за исключением того, что первый элемент — самый большой, поэтому чтобы быть полностью уверенным пришлось сделать своё.

Удалить произвольный элемент из кучи тоже можно:

some_iterator heap_begin, heap_end;
some_iterator to_delate_from_heap;
*to_delete_from_heap = *( heap_end - 1 );
--heap_end;
update_heap( heap_begin, heap_end, to_delete_from_heap );

Собственно код:

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

/// \file heapext.h

#ifndef heapext_h
#define heapext_h

#include <cassert>
#include <utility>
#include <iterator>

namespace heapext
{
    namespace detail
    {
        template<typename t_iter, typename t_diff, typename t_value>
        inline void down_heap( t_iter begin, t_diff size, t_diff idx, t_value val )
        {
            while( idx < size )
            {
                t_diff const left = 2*idx + 1;
                t_diff const right = 2*idx + 2;

                t_diff largest;
                if( right < size )
                    largest = *( begin + right ) < *( begin + left ) ? left : right;
                else if( left < size )
                    largest = left;
                else
                    break;

                if( val < *( begin + largest ) )
                {
                    *( begin + idx ) = std::move( *( begin + largest ) );
                    idx = largest;
                }
                else
                    break;
            }

            *( begin + idx ) = std::move( val );
        }

        template<typename t_iter, typename t_diff, typename t_value>
        inline void up_heap( t_iter begin, t_diff idx, t_value val )
        {
            t_diff parent = ( idx - 1 )/2;
            while( idx && *( begin + parent ) < val )
            {
                *( begin + idx ) = std::move( *( begin + parent ) );
                idx = parent;
                parent = ( idx - 1 )/2;
            }
            *( begin + idx ) = std::move( val );
        }

        template<typename t_iter, typename t_diff, typename t_value, typename t_cmp>
        inline void down_heap( t_iter begin, t_diff size, t_diff idx, t_value val, t_cmp cmp )
        {
            while( idx < size )
            {
                t_diff const left = 2*idx + 1;
                t_diff const right = 2*idx + 2;

                t_diff largest;
                if( right < size )
                    largest = cmp( *( begin + right ), *( begin + left ) ) ? left : right;
                else if( left < size )
                    largest = left;
                else
                    break;

                if( cmp( val, *( begin + largest ) ) )
                {
                    *( begin + idx ) = std::move( *( begin + largest ) );
                    idx = largest;
                }
                else
                    break;
            }

            *( begin + idx ) = std::move( val );
        }

        template<typename t_iter, typename t_diff, typename t_value, typename t_cmp>
        inline void up_heap( t_iter begin, t_diff idx, t_value val, t_cmp cmp )
        {
            t_diff parent = ( idx - 1 )/2;
            while( idx && cmp( *( begin + parent ), val ) )
            {
                *( begin + idx ) = std::move( *( begin + parent ) );
                idx = parent;
                parent = ( idx - 1 )/2;
            }
            *( begin + idx ) = std::move( val );
        }
    }

    template<typename t_iter>
    inline void push_heap( t_iter begin, t_iter end )
    {
        assert( end - begin >= 1 );
        detail::up_heap( begin, end - begin - 1, std::move( *( end - 1 ) ) );
    }

    template<typename t_iter>
    inline void pop_heap( t_iter begin, t_iter end )
    {
        assert( end - begin >= 1 );
        typename std::iterator_traits<t_iter>::value_type val = std::move( *( end - 1 ) );
        *( end - 1 ) = std::move( *begin );
        detail::down_heap( begin, end - begin - 1, 0, std::move( val ) );
    }

    /// Same as pop_heap, but didn't move *begin to *(end-1)
    template<typename t_iter>
    inline void pop_heap_drop( t_iter begin, t_iter end )
    {
        assert( end - begin >= 1 );
        detail::down_heap( begin, end - begin - 1, 0, std::move( *( end - 1 ) ) );
    }

    template<typename t_iter>
    inline void update_heap( t_iter begin, t_iter end, t_iter changed )
    {
        assert( end - begin >= 1 );
        assert( begin <= changed && changed < end );

        typedef typename std::iterator_traits<t_iter>::value_type t_value;
        typedef typename std::iterator_traits<t_iter>::difference_type t_diff;

        t_diff const idx = changed - begin;
        t_diff const parent = ( idx - 1 )/2;
        if( idx > 0 && *( begin + parent ) < *changed )
            detail::up_heap( begin, idx, std::move( *changed ) );
        else
            detail::down_heap( begin, end - begin, idx, std::move( *changed ) );
    }

    template<typename t_iter>
    inline void make_heap( t_iter begin, t_iter end )
    {
        typedef typename std::iterator_traits<t_iter>::difference_type t_diff;
        t_diff const size = end - begin;
        for( t_diff idx = size/2 - 1; idx >= 0; --idx )
            detail::down_heap( begin, size, idx, std::move( *( begin + idx ) ) );
    }

    template<typename t_iter>
    inline void sort_heap( t_iter begin, t_iter end )
    {
        while( end - begin > 1 )
            heapext::pop_heap( begin, end-- );
    }

    template<typename t_iter, typename t_cmp>
    inline void push_heap( t_iter begin, t_iter end, t_cmp cmp )
    {
        assert( end - begin >= 1 );
        detail::up_heap( begin, end - begin - 1, std::move( *( end - 1 ) ), cmp );
    }

    template<typename t_iter, typename t_cmp>
    inline void pop_heap( t_iter begin, t_iter end, t_cmp cmp )
    {
        assert( end - begin >= 1 );
        typename std::iterator_traits<t_iter>::value_type val = std::move( *( end - 1 ) );
        *( end - 1 ) = std::move( *begin );
        detail::down_heap( begin, end - begin - 1, 0, std::move( val ), cmp );
    }

    /// Same as pop_heap, but didn't move *begin to *(end-1)
    template<typename t_iter, typename t_cmp>
    inline void pop_heap_drop( t_iter begin, t_iter end, t_cmp cmp )
    {
        assert( end - begin >= 1 );
        detail::down_heap( begin, end - begin - 1, 0, std::move( *( end - 1 ) ), cmp );
    }

    template<typename t_iter, typename t_cmp>
    inline void update_heap( t_iter begin, t_iter end, t_iter changed, t_cmp cmp )
    {
        assert( end - begin >= 1 );
        assert( begin <= changed && changed < end );

        typedef typename std::iterator_traits<t_iter>::value_type t_value;
        typedef typename std::iterator_traits<t_iter>::difference_type t_diff;

        t_diff const idx = changed - begin;
        t_diff const parent = ( idx - 1 )/2;
        if( idx > 0 && cmp( *( begin + parent ), *changed ) )
            detail::up_heap( begin, idx, std::move( *changed ), cmp );
        else
            detail::down_heap( begin, end - begin, idx, std::move( *changed ), cmp );
    }

    template<typename t_iter, typename t_cmp>
    inline void make_heap( t_iter begin, t_iter end, t_cmp cmp )
    {
        typedef typename std::iterator_traits<t_iter>::difference_type t_diff;
        t_diff const size = end - begin;
        for( t_diff idx = size/2 - 1; idx >= 0; --idx )
            detail::down_heap( begin, size, idx, std::move( *( begin + idx ) ), cmp );
    }

    template<typename t_iter, typename t_cmp>
    inline void sort_heap( t_iter begin, t_iter end, t_cmp cmp )
    {
        while( end - begin > 1 )
            heapext::pop_heap( begin, end--, cmp );
    }
}

#endif //heapext_h

Простой SAX парсер, только в заголовочных файлах

Sat, 08 Jan 2011 18:20:42 GMT

Здравствуйте, коллеги!

Понадобился легковесный XML SAX парсер, ничего подходящего не нашел, набросал сам. Перекодировки не поддерживает, подразумевается UTF-8 при преобразовании entities в текст, в остальном — кодировка не важна. В принципе, этот момент можно обработать самому, особых проблем не вижу. Может и сам потом допилю.
Используется два файла — rel_ASAX_Automata.h — автогенеренный файл с разбирающим автоматом, simplesax.h — основной файл парсера
(в simplesax.h нужно удалить ссылку на dbg_ASAX_Automata.h, это автомат с отладочным выводом, я его опустил тут ).

Замечание. При наличии атрибутов у тега сначала вызывается событие startElement, затем attribute для имени атрибута и attributeValue для значения атрибута.
attribute и attributeValue обычно вызываются попарно, но attributeValue может не вызыватся, если атрибут не имеет значения.
Если тэг пустой и сам себя закрывает (<SomeTag/>), то для него будут вызваны startElement и endElement с корректным именем тэга в обоих случаях.
Если тэг с атрибутами сам себя закрывает (<SomeTag attr="val"/>), то для него будут вызваны startElement, attribute, attributeValue, затем endElement с пустым именем тэга.

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

struct CSaxPrintHandler : public ::cli::sax::CSaxDefaultHandler // ::cli::sax::CSaxHandler
{
    ::std::string str(const char *p, size_t len)
       {
        if (!p || !len) return ::std::string();
        return ::std::string( p, len );
       }

    void characters( const char *pchars, size_t len )
       {
        std::cout<<"Text         : ";
        std::cout<< str( pchars, len );
        std::cout<<"\n";
       }

    void cdataSection( const char *pchars, size_t len )
       {
        std::cout<<"CDATA        : ";
        std::cout<< str( pchars, len );
        std::cout<<"\n";
       }

    void comment( const char *pchars, size_t len )
       {
        std::cout<<"Comment      : ";
        std::cout<< str( pchars, len );
        std::cout<<"\n";
       }

    void startDocument()
       {
        std::cout<<"Document start\n";
       }

    void endDocument()
       {
        std::cout<<"Document end\n";
       }

    void startElement( const char *ns, size_t nsLen
                   , const char *elem, size_t elemLen
                   , const char *elemFull, size_t elemFullLen // ns:tag
                   )
       {
        std::cout<<"Start element: ";
        std::cout<< str( elemFull, elemFullLen )<< " (ns: '"<<str(ns, nsLen)<<"', name: '"<<str(elem, elemLen)<<"')";
        std::cout<<"\n";
       }

    void endElement( const char *ns, size_t nsLen
                   , const char *elem, size_t elemLen
                   , const char *elemFull, size_t elemFullLen // ns:tag
                   )
       {
        std::cout<<"End element  : ";
        std::cout<< str( elemFull, elemFullLen )<< " (ns: '"<<str(ns, nsLen)<<"', name: '"<<str(elem, elemLen)<<"')";
        std::cout<<"\n";
       }

    void processingInstruction( const char *pi, size_t piLen )
       {
        std::cout<<"PI           : ";
        std::cout<< str( pi, piLen );
        std::cout<<"\n";
       }

    void attribute( const char *ns, size_t nsLen
                   , const char *attr, size_t attrLen
                   , const char *attrFull, size_t attrFullLen // ns:attr
                   )
       {
        std::cout<<"Attribute    : ";
        std::cout<< str( attrFull, attrFullLen ) << " (ns: '"<<str(ns, nsLen)<<"', name: '"<<str(attr, attrLen)<<"')";
        std::cout<<"\n";
       }

    void attributeValue( const char *attrVal, size_t attrValLen )
       {
        std::cout<<"Attribute val: ";
        std::cout<< str( attrVal, attrValLen );
        std::cout<<"\n";
       }
};

...


    ::std::string data = ""; // place XML here
    // RCODE res = ::cli::misc::utils::readFile( inputStreamName, data );
    // if (res) return res;
    
    CSaxPrintHandler handler;
    ::cli::sax::CSimpleSaxParser< ::cli::sax::CSaxStdStringBuffer > parser;

    if ( ::cli::sax::parse( &parser, &handler, data ) < 0 )
       {
        std::cout<<"SAX failed\n";
       }

Тестовый XML

<?xml version="1.0"?>
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body>
<alone-with-attr attr="1"/>
<!-- Comment test 1 --><!-- Comment test 2 -->
<![CDATA[<!-- Comment test 1 --><!-- Comment test 2 --> ]]>
<u:GetCommonLinkProperties xmlns:u="urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1">
<NewRemoteHost xmlns:dt="urn:schemas-microsoft-com:datatypes" dt:dt="string">New&apos;Remote Host</NewRemoteHost>
<NewExternalPort xmlns:dt="urn:schemas-microsoft-com:datatypes" dt:dt="ui2">110</NewExternalPort>
<NewProtocol xmlns:dt="urn:schemas-microsoft-com:datatypes" dt:dt="string">TCP</NewProtocol>
<NewInternalPort xmlns:dt="urn:schemas-microsoft-com:datatypes" dt:dt="ui2">110</NewInternalPort>
<NewInternalClient xmlns:dt="urn:schemas-microsoft-com:datatypes" dt:dt="string"></NewInternalClient>
<NewEnabled xmlns:dt="urn:schemas-microsoft-com:datatypes" dt:dt="boolean">0</NewEnabled>
<NewPortMappingDescription xmlns:dt="urn:schemas-microsoft-com:datatypes" dt:dt="string">Virtual Server POP3</NewPortMappingDescription>
<NewLeaseDuration xmlns:dt="urn:schemas-microsoft-com:datatypes" dt:dt="ui4">0</NewLeaseDuration>
</u:GetCommonLinkProperties>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>

Вывод

Document start
PI : xml version="1.0"
Start element: SOAP-ENV:Envelope (ns: 'SOAP-ENV', name: 'Envelope')
Attribute : xmlns:SOAP-ENV (ns: 'xmlns', name: 'SOAP-ENV')
Attribute val: http://schemas.xmlsoap.org/soap/envelope/
Attribute : SOAP-ENV:encodingStyle (ns: 'SOAP-ENV', name: 'encodingStyle')
Attribute val: http://schemas.xmlsoap.org/soap/encoding/
Start element: SOAP-ENV:Body (ns: 'SOAP-ENV', name: 'Body')
Start element: alone-with-attr (ns: '', name: 'alone-with-attr')
Attribute : attr (ns: '', name: 'attr')
Attribute val: 1
End element : (ns: '', name: '')
Comment : Comment test 1
Comment : Comment test 2
CDATA : 
Start element: u:GetCommonLinkProperties (ns: 'u', name: 'GetCommonLinkProperties')
Attribute : xmlns:u (ns: 'xmlns', name: 'u')
Attribute val: urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1
Start element: NewRemoteHost (ns: '', name: 'NewRemoteHost')
Attribute : xmlns:dt (ns: 'xmlns', name: 'dt')
Attribute val: urn:schemas-microsoft-com:datatypes
Attribute : dt:dt (ns: 'dt', name: 'dt')
Attribute val: string
Text : New'Remote Host
End element : NewRemoteHost (ns: '', name: 'NewRemoteHost')
Start element: NewExternalPort (ns: '', name: 'NewExternalPort')
Attribute : xmlns:dt (ns: 'xmlns', name: 'dt')
Attribute val: urn:schemas-microsoft-com:datatypes
Attribute : dt:dt (ns: 'dt', name: 'dt')
Attribute val: ui2
Text : 110
End element : NewExternalPort (ns: '', name: 'NewExternalPort')
Start element: NewProtocol (ns: '', name: 'NewProtocol')
Attribute : xmlns:dt (ns: 'xmlns', name: 'dt')
Attribute val: urn:schemas-microsoft-com:datatypes
Attribute : dt:dt (ns: 'dt', name: 'dt')
Attribute val: string
Text : TCP
End element : NewProtocol (ns: '', name: 'NewProtocol')
Start element: NewInternalPort (ns: '', name: 'NewInternalPort')
Attribute : xmlns:dt (ns: 'xmlns', name: 'dt')
Attribute val: urn:schemas-microsoft-com:datatypes
Attribute : dt:dt (ns: 'dt', name: 'dt')
Attribute val: ui2
Text : 110
End element : NewInternalPort (ns: '', name: 'NewInternalPort')
Start element: NewInternalClient (ns: '', name: 'NewInternalClient')
Attribute : xmlns:dt (ns: 'xmlns', name: 'dt')
Attribute val: urn:schemas-microsoft-com:datatypes
Attribute : dt:dt (ns: 'dt', name: 'dt')
Attribute val: string
End element : NewInternalClient (ns: '', name: 'NewInternalClient')
Start element: NewEnabled (ns: '', name: 'NewEnabled')
Attribute : xmlns:dt (ns: 'xmlns', name: 'dt')
Attribute val: urn:schemas-microsoft-com:datatypes
Attribute : dt:dt (ns: 'dt', name: 'dt')
Attribute val: boolean
Text : 0
End element : NewEnabled (ns: '', name: 'NewEnabled')
Start element: NewPortMappingDescription (ns: '', name: 'NewPortMappingDescription')
Attribute : xmlns:dt (ns: 'xmlns', name: 'dt')
Attribute val: urn:schemas-microsoft-com:datatypes
Attribute : dt:dt (ns: 'dt', name: 'dt')
Attribute val: string
Text : Virtual Server POP3
End element : NewPortMappingDescription (ns: '', name: 'NewPortMappingDescription')
Start element: NewLeaseDuration (ns: '', name: 'NewLeaseDuration')
Attribute : xmlns:dt (ns: 'xmlns', name: 'dt')
Attribute val: urn:schemas-microsoft-com:datatypes
Attribute : dt:dt (ns: 'dt', name: 'dt')
Attribute val: ui4
Text : 0
End element : NewLeaseDuration (ns: '', name: 'NewLeaseDuration')
End element : u:GetCommonLinkProperties (ns: 'u', name: 'GetCommonLinkProperties')
End element : SOAP-ENV:Body (ns: 'SOAP-ENV', name: 'Body')
End element : SOAP-ENV:Envelope (ns: 'SOAP-ENV', name: 'Envelope')
Document end

Template Endian Switcher

Sat, 08 Jan 2011 15:31:46 GMT

Пара вопросов по данному коду:

template<int size>
struct Endian
{
  static inline void Switch(void * buff);
};
template<int size>  
inline void Endian<size>::Switch(void * buff)
  {
    std::swap(((char*)buff)[0], ((char*)buff)[size-1]);
    Endian<size-2>::Switch((char*)buff + 1);
  }

template<>
inline void Endian<0>::Switch(void * ){}

template<typename T>
void SwitchEndian(T * value, size_t count = 1)
{
  for (size_t i =0; i < count; ++i)
    Endian<sizeof(T)>::Switch(value+i);
}

Во первых, оно будет корректно работать?
Во вторых, чем оно лучше/хуже обёртки вокруг hton и ко.?

Небольшой

Tue, 21 Dec 2010 17:01:57 GMT

Предыстория.
Был найден такой кусочек кода:

DWORD info_length = 0;

if ( !::GetTokenInformation( token.handle(), TokenGroups, 0, 0, &info_length ) && 
                            ERROR_INSUFFICIENT_BUFFER != ::GetLastError() )
    throw an_exception( ::GetLastError() );

std::vector<BYTE> buffer( info_length );   

if ( !::GetTokenInformation( token.handle(), TokenGroups, &buffer[0], info_length, &info_length ) )
    throw an_exception( ::GetLastError() );

Это далеко не единственная winapi, которая возвращает размер буфера для своей работы. Но данный случай интересен тем, что далее:

PTOKEN_GROUPS  pGroups = reinterpret_cast<PTOKEN_GROUPS>( &buffer[0] ); 

for ( DWORD i = 0; i < pGroups->GroupCount && !m_admin; ++ i )
{
    if ( ::EqualSid( psid, pGroups->Groups[i].Sid ) )
        m_admin = true;
}

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

smart_buffer<PTOKEN_GROUPS,DWORD> buffer;

if ( !::GetTokenInformation( token.handle(), TokenGroups, 0, 0, buffer.psize() ) )
{
    DWORD err_code = ::GetLastError();

    if ( ERROR_INSUFFICIENT_BUFFER != err_code )
        throw an_exception( err_code );

    if ( !::GetTokenInformation( token.handle(), TokenGroups, buffer, buffer.size(), buffer.psize() ) )
        throw an_exception( ::GetLastError() );
}

Конечно же, кастинг никуда не делся. По крайней мере, он не мозолит глаз в клиентском коде.

for ( DWORD i = 0; i < buffer->GroupCount && !m_admin; ++ i )
{
    if ( ::EqualSid( psid, buffer->Groups[i].Sid ) )
        m_admin = true;
}

Сам класс:

typedef std::vector<BYTE> buffer; 

template <typename T, typename sizeT = buffer::size_type>
class smart_buffer : buffer
{
    friend class buffer_size_proxy;

public:

    typedef T        value_type;
    typedef sizeT    size_type;

    using buffer::size;

    template <typename BufferT>
    class buffer_size_proxy
    {
        BufferT& buffer_;
        typename BufferT::size_type size_; 
        typename const BufferT::size_type initial_size_; 
        size_t ref_cnt_;

    public:
        buffer_size_proxy( BufferT& buffer )
            :    buffer_( buffer ),
                size_( buffer.size() ),
                initial_size_( size_ ),
                ref_cnt_( 1 )
        {
        }

        ~buffer_size_proxy()
        {
            if ( 0 == -- ref_cnt_ && initial_size_ < size_ )
                buffer_.resize( size_ );
        }
        
        buffer_size_proxy( const buffer_size_proxy& rhs )
            :    buffer_( rhs.buffer_ ),
                size_( rhs.size_ ),
                ref_cnt_( rhs.ref_cnt_ + 1 )
        {
        }

        operator typename BufferT::size_type * ()
        {
            return &size_;
        }
    };

public:

    smart_buffer() 
    {
    }

    smart_buffer( size_type initial_size )
        :    buffer( initial_size )
    {
    }

    buffer_size_proxy<smart_buffer<T,sizeT>> psize()
    {
        return buffer_size_proxy<smart_buffer>( *this );
    }

    operator T()
    {
        return reinterpret_cast<T>( &operator[]( 0 ) );
    }

    const T operator -> ()
    {
        return reinterpret_cast<const T>( &at( 0 ) );
    }
};

Идея заключается в использовании временного прокси-объекта, неявно управляющего выделением памяти. Нет надобности заводить вспомогательные переменные и делать кастинг. Да и вообще
Написано в некоторой спешке, критика горячо приветствуется.
Спасибо за внимание.