SKHAZ’s Blog

Em programação não existe plágio, na verdade tudo é refactory em código fonte alheio

Achei esse link ao acaso e achei útil para quem usa o wordpress como ferramenta de blogging WORDPRESS GOD: 300+ Tools for Running Your WordPress Blog

E para quem usa o VIM, O vimpress esse plugin (do vim, e não do wordpress) permite postar e editar posts pelo editor sem ter que sair do conforto do vim.

[Via youtube]

Achei esse meme e então resolvi participar

history|awk '{print $2}'|awk 'BEGIN {FS="|"} {print $1}'|sort|uniq -c|sort -rn|head -10

Resultado

1. ls
2. cd
3. vim
4. g++
5. mplayer
6. startx
7. lynx
8. ps
9. mc
10. tar

Fica registrado meu “intimado” a todos que lêem me blog, postarem os 10 ultimo mais usados comando do linux (ou qualquer outro *nix)

Para quem ainda tem dificuldades para compilar a biblioteca boost, eu encontrei um instalador que baixa os pacotes dependendo de suas escolhas (multithreaded, static, debug, etc) sem contar que nos polpa de ter que esperar pela compilação, pena que é só para o Visual C++.

O instalador pode ser baixado aqui, mais informações em http://www.boost-consulting.com/products/free

Essa é minha implementação de um pequeno sistema de agendamento de tarefas, que futuramente usarei em um outro projeto, achei que ficou legal então resolvi postar. Vamos à implementação

task.hpp

#ifndef _task_hpp
#define _task_hpp

#include <ctime>
#include <boost /function.hpp>
#include </boost><boost /bind.hpp>

class task
{
	public:
		explicit task(const boost::function<void ()>& callback)
		: _call_back(callback)
		, _call_count(0)
		, _total_time_used(0)
		{
		}

		virtual ~task() { }

		virtual void before_task() { }

		void do_task()
		{
			before_task();
			_call_back();
			after_task();
		}

		virtual void after_task() { }

		void set_callback(const boost::function</void><void ()>& callback)
		{
			_call_back = callback;
		}

		const boost::function</void><void ()>& get_callback() const
		{
			return _call_back;
		}

		bool is_valid() const
		{
			return true;
		}

	private:
		boost::function</void><void ()> _call_back;
		std::size_t _call_count;
		std::clock_t _total_time_used;
};

#endif

schedule.hpp

#ifndef _schedule_hpp
#define _schedule_hpp

#include <algorithm>
#include <deque>
#include <boost /pool/pool_alloc.hpp>
#include </boost><boost /shared_ptr.hpp>
#include </boost><boost /noncopyable.hpp>
#include </boost><boost /thread/thread.hpp>
#include </boost><boost /thread/xtime.hpp>
#include </boost><boost /thread/mutex.hpp>

#include "task.hpp"

using std::for_each;
using std::deque;
using boost::shared_ptr;

class task;
typedef shared_ptr<task> task_ptr;
typedef deque<task_ptr , boost::pool_allocator<task_ptr> > deque_task;

class schedule : public boost::noncopyable
{
	public:
		schedule() : job(boost::bind(&schedule::thread_dispatcher, this))
		{
			_thread_sleep.sec = 10;

			try
			{
				job.join();
			}

			catch (boost::thread_interrupted&) { /* don't care... */ }
		}

		virtual ~schedule() { }

		void add_task(const shared_ptr<task>& _task)
		{
			boost::mutex::scoped_lock lock(monitor);

			deque_task::const_iterator it = std::find(_task_pool.begin(),
					_task_pool.end(), _task);

			if (it == _task_pool.end())
			{
				_task_pool.push_back(_task);
			}

			else {
				// duplicate item
			}
		}

		void remove_task(const shared_ptr</task><task>& _task)
		{
			boost::mutex::scoped_lock lock(monitor);

			deque_task::iterator it = std::find(_task_pool.begin(),
					_task_pool.end(), _task);

			if (it != _task_pool.end())
			{
				_task_pool.erase(it);
			}

			else {
				// does't exist
			}
		}

	protected:
		void thread_dispatcher()
		{
			for (;;)
			{
				for_each(_task_pool.begin(), _task_pool.end(),
					boost::mem_fn(&task::do_task));

				boost::thread::sleep(_thread_sleep);
			}
		}

	private:
		deque_task _task_pool;
		boost::thread job;
		boost::mutex monitor;
		boost::xtime _thread_sleep;
};

#endif

Unidade para testes, main.cpp

#include <iostream>
#include <boost /scoped_ptr.hpp>
#include </boost><boost /bind.hpp>

#include "schedule.hpp"

void f1()
{
	std::cout < < "f1()" << std::endl;
}

void f2()
{
	std::cout << "f2()" << std::endl;
}

int main()
{
	boost::scoped_ptr<schedule> _schedule(new schedule());

	shared_ptr<task> _task1 (new task(f1));
	shared_ptr</task><task> _task2 (new task(f2));

	_schedule->add_task(_task1);
	_schedule->add_task(_task1); // repetido, nao insere...
	_schedule->add_task(_task2);

	_schedule->start();

	return 0;
}

Agradecimentos

• Daniel pela sugestão de usar fila e apenas uma thread ao invés de uma para cada tarefa e assim evitando busy-waiting
• Alex pelos testes de compatibilidade com mingw e msvc (vide mem_fun e shared_ptr)

schedule.zip

Recentemente tive problemas com mem_fun e shared_ptr em um loop for_each

Os elementos

typedef shared_ptr<task> task_ptr;
typedef deque<task_ptr , pool_allocator<task_ptr> > deque_task_ptr;

Agora a combinação explosiva

for_each(_task_pool.begin(), _task_pool.end(),
       std::mem_fun(&task::do_task));

O problema está em usar std::mem_fun, ela não suporta chamar métodos de uma classe que estão em um shared_ptr, eu poderia ter usado bind, mais preferi manter o código, como a boost tem sua própria implementação de mem_fn ficando assim:

for_each(_task_pool.begin(), _task_pool.end(),
       boost::mem_fn(&task::do_task));

Resolvido, obrigado Alex por reportar o problema.

Respondendo ao meme do Vínicius, Eu não gosto de muitos icones no desktop, prefiro usar o “Inicialização Rapida”

IDE: Codeblocks, Visual Studio 2008 e wxFormBuilder (valeu a indicação n2liquid)
Jogos: Diablo II, Starcraft, Turok 2
Outros softwares: Winamp, Kaspersky, Opera, Media Player Classic, DVD Shrink, Nero.
Tem alguns eBooks no canto superior, e no superior esquerdo alguns projetos.
Tema usado é o Zune, e minha taskbar eu sempre uso com o tamanho dobrado (talvez seja um abito vindo do KDE), Ah é.. e como muita gente limpou o desktop para a “visita”, eu tambem dei uma enxugada no meu xD

A imagem está em baixa resolução porque meu monitor parou de funcionar e estou só com um reserva :(

Edit Visual Studio com tema modificado

Instalei o ClickHeat no blog, para quem ainda não conhece ele registra os clicks dos visitantes e posteriormente gera gráficos com a temperatura dos clicks, abaixo algumas screenshots do ClickHeat rodando há 2 dias.

Os pontos azuis são os clicks, quanto mais avermelhado mais clicks em um determinado ponto

O que é PhysicsFS
PhysicsFS (Physics File System) ou physfs, fornece uma camada de abstração do sistema de arquivos do sistema operacional.

Motivação
Quando estava escrevendo a wintermoon estudei varias engines dentre elas a Ogre e a Irrlicht cada uma possui seu próprio sistema de arquivo virtual como descrito acima. mais porque a PhysicsFS? bom além de ser considerada muito segura e portável, ela tem um wrapper para a estrutura SDL_RWops o que facilita muito para projetos usando a biblioteca SDL. Outro ponto forte é a segurança, sua aplicação apenas poderá acessar os diretórios que você escolher, ideal para projetos baseados em scripts.

Recursos
Formatos suportados

• grp - groupfiles ou seja vários arquivos em um só sem compressão
• hog - maiores informações em href=”http://www.descent2.com/ddn/specs/hog
• lzma - formato popular usado pelo 7z
• mvl - Descent II Movielib, mais informações em http://www.descent2.com/ddn/specs/mvl/
• qpak - formato de arquivo usado no Quake 1, Quake 2 e Quake 3
• wad - usado na engine do DOOM
• zip - formato popular e muito usado

Extras

• selfextract - suporta autoextração do executável
• ignorecase - torna não case-sensitive (não diferencia maiúsculo de minusculo)
• wildcard - mascara ex. arquivo.*, *.zip, arqui??.*, *.zi?
• physfsrwops - abstração da estrutura SDL_RWops (é o que vamos usar, será mais explicado adiante)
• physfshttpd - Possibilita enviar ou receber arquivos via http

Leia o restante desta entrada »