class Foo {
public:
  methodA() {
    printf("Wykonano...\n");
  }
}

struct data_t {
  int i_;
  Foo* obj_;
}

std::list<data_t*> data_;

for(std::list<data_t*>::iterator i  = data_.begin(); i != data_.end(); i++ ) {
   // operacje
}

W jaki sposób wykonać blok operacji ? Możliwości mamy kilka:

/* 1 */ i->obj_->methodA();
/* 2 */ *i->obj_->methodA();
/* 3 */ (*i)->obj_->methodA();

Rozwiązanie zagadki jest proste, ale wymaga znajomości priorytetów operatorów. Pierwsze wywołania jest całkowicie błędne, ponieważ lista przecowuje wskaźniki do strkutury, a nie samą strukturę. Zatem należy najpier wyłuskać strukturę znajdującą się pod wskazywanym adresem i dopiero wtedy wykonać metodę. Okazuje się że rowiązania 2 również jest nie poprawne, właśnie ze względu na priorytety operatorów. Dopiero numer 3 daje zamierzony efekt. Na szczęście błąd ujawnia się na etapie kompilacji…

set tabstop=4
set shiftwidth=4
set expandtab

Na sam koniec warto dodać, że mimo iż Vim może być postrzegany jako stary edytor, trudny w użyciu a posługują się nim tylko starzy wyjadacze-programiści z poprzedniej epoki, to ma on wiele funkcji których nie oferuje nawet Notepad++, a programowanie bez odrywania rąk od klawiatury jest o wiele mniej męczące. Polecam cheatsheet: http://www.qitty.net/lnx/vim-cheatsheet.png

Modyfikator out
Modyfikatorem out można oznaczyć dowolną liczbę parametrów metody. Nie ma przy tym znaczenia kolejność, parametry zmodyfikowane przez out mogą wystąpić zarówno na początku listy w środku jak i na końcu. To słowo kluczowe definiuje tzw. parametr wyjściowy. Wykonanie funkcji wymaga zapisania wartości do parametru wyjściowego.

        public static void Dodawanie(out int sum, int x, int y, out int ssum)
        {
            sum = x + y;
            ssum = sum * sum;
        }

Jeśli kompilator nie znajdzie prawidłowego(co można wymusić komentując linię ssum = sum*sum) przypisania wygeneruje błąd i poinformuje nas o tym komunikatem:

„The out parameter ‘ssum’ must be assigned to before control leaves the current method”

Modyfikator out, może trochę przypominać mechanizm znany z C polegający na przekazywaniu wskaźnika jako parametru funkcji. Jednak w przypadku C# mamy pewność że po wykonaniu podprogramu, w parametrze wyjściowym znajdzie się jakąś wartość, co chroni nas przed nieprzyjemnym komunikatem „Segmentation fault”. Istnieje jeszcze jedna różnica wpływająca na korzyść platformy .NET, mianowicie sposób wywołania. Nie ma tu magicznych zaklęć nie trzeba się domyślać który parametr to wskaźnik i jak został przekazany, ponieważ trzeba to jawnie określić. Kompilator umożliwi uruchomienie programu tylko wtedy gdy wszystkie wywołania funkcji zostaną opisane zgodnie z ich deklaracjami/definicjami, znakomicie wpływa to na czytelność kodu:

        static void Main(string[] args)
        {
            int sum, ssum;
            int a = 5, b = 6;

            Dodawanie(out sum, a, b, ssum);       // FAIL !
            Dodawanie(out sum, a, b, out ssum); // OK !

            Console.WriteLine("Suma {0} + {1} = {2}, ({0} + {1})^2 = {3}", a, b, sum, ssum);
            Console.ReadLine();
        }

Modyfikator ref
Działanie modyfikatora ref również jest związane z wywołaniem metod. Jednakże jego zastosowanie ma sens tylko w odniesieniu do obiektów które w łańcuchu dziedziczenia nie mają klasy System.ValueType, a więc takich które tworzone są na stercie i nie są przekazywane przez wartość ale przez referencję. Podobnie jak w przypadku Javy, modyfikacje wykonane na takim obiekcie pozostają aktualne po zakończeniu metody, o czym napisałem we wpisie Pass-by-value w javie. Dla przypomnienia: tak naprawdę przekazywana jest nie referencja a jej kopia, z tego powodu dozwolona jest zmiana stanu obiektu ale przypisanie referencji do innego obiektu już nie. Aby lepiej zrozumieć zagadnienie przedstawiam prosty przykład prezentujący wspomnianą funkcjonalność:

class Punkt
{
  public int x;
  public int y;
}

class Program
{

  public static void CopyReference(Punkt p)
  {
    p.x = 0;
    p.y = 0;

    p = new Punkt();
    p.x = 200;
    p.y = 200;
  }

static void Main(string[] args)
{
  Punkt p1 = new Punkt();
  p1.y = 100;
  p1.x = 100;

  Console.WriteLine("Przed wykonaniem CopyReference: p1.x = {0}, p1.y = {1}", p1.x, p1.y);
  CopyReference(p1);
  Console.WriteLine("Po wykonaniem CopyReference: p1.x = {0}, p1.y = {1}";, p1.x, p1.y);
  Console.ReadLine();

  }
}

W wyniku wykonania programu powinniśmy zobaczyć na ekranie następujący wynik:

Przed wykonaniem CopyReference: p1.x = 100, p1.y = 100
Po wykonaniem CopyReference: p1.x = 0, p1.y = 0

Aby osiągnąć zamierzone działanie wystarczy dodać modyfikator ref, zarówno do definicji metody, jak i do jej wywołania pdobnie jak ma to miejsce w przypadku „out”:

public static void OrigReference(ref Punkt p)
{
  p.x = 0;
  p.y = 0;

  p = new Punkt();
  p.x = 200;
  p.y = 200;
}

Po wykonaniu tak zmodyfikowanej metody, pola x oraz y obiektu p1 będą przechowywały wartość (200, 200)
AFAIK w Javie takich możliwości nie ma, może konstrukcje takie nie są szczególnie przydatne, ale w .NET w razie czego są i można je wykorzystać co pozytywnie wpływa na moja dotychczasową ocenę tej platformy.

// Copyright (C) 2001-2003
// William E. Kempf
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation.  William E. Kempf makes no representations
// about the suitability of this software for any purpose.
// It is provided "as is" without express or implied warranty.

#include <boost/thread/thread.hpp>;
#include <;boost/thread/xtime.hpp>;
#include <iostream>;

struct thread_alarm
{
    thread_alarm(int secs) : m_secs(secs) { }
    void operator()()
    {
        boost::xtime xt;
        boost::xtime_get(&xt, boost::TIME_UTC);
        xt.sec += m_secs;

        boost::thread::sleep(xt);

        std::cout << "alarm sounded..." << std::endl;
    }

    int m_secs;
};

int main(int argc, char* argv[])
{
    int secs = 5;
    std::cout << "setting alarm for 5 seconds..." << std::endl;
    thread_alarm alarm(secs);
    boost::thread thrd(alarm);
    thrd.join();
}

Jednak ten sposób nie działa w przypadku korzystania z natywnego mechanizmu wielowątkowości dostępnego w każdym systemie *nix. Biblioteka pthreads nie radzi sobie z wywołaniem przeciążonego operatora (). Problem trzeba było rozwiązać jak najszybciej, żeby projekt mógł ruszy dalej. Dlatego powstał ten sprytny „work-around” umożliwiający uruchomienie dowolnej metody obiektu w nowym wątku. Jest to właściwie funkcja proxy, takie proste a ułatwia życie:

template<class T>
struct ThreadParams
{
	T *obj;
	void *params;
};

template<class T, void* (T::*method)(void*)>
void* run_thread(void *params)
{
	ThreadParams<T> *t = static_cast<ThreadParams><T*>(params);
	T* obj = static_cast<T*>(t->obj);
	(obj->*method)(t->params);
	return NULL;
}

Dodatkowy wkład pracy jaki należy włożyć aby wykorzystać powyższy kod ogranicza się właściwie tylko do wypełnienia struktury ThreadParams:

class Test
{
public:
	void* fun(void* params) {
	printf("Hello World! \n");
	printf("Params: %d\n", reinterpret_cast<int>(params));
	pthread_exit(NULL);
	}
 };

 int main() {

	pthread_t tid;
	void* status;
	Test test;
	ThreadParams<Test> params;

	params.obj = &test;
	params.params = reinterpret_cast<void>(123);

	pthread_create(&tid, NULL, run_thread<Test, &Test::fun>, (void*)(&params));
	pthread_join(tid, &status);
 }

Java Persistence Api (JPA) jest wykorzystywane do mapowania encji zapisanych w bazie danych (wiersze tabeli) na ich obiektową reprezentację również nazywaną encją. Zbieżność terminów może powodować konsternację dlatego w dalszej części wpisu przez pojęcie encja należy rozumieć tylko odpowiednio opisaną klasę w języku Java.
W ogólnym wypadku każda klasa spełniająca wymogi JavaBean tj. posiadająca bezparametrowy konstruktor oraz metody get i set dla pól może zostać przekształcona w encję. Dla przykładu, Grupa może zostać opisana przez taki komponent:

package eu.doniec.piotr.bean

public class Grupa {
    private Long id;

    private String nazwa;
    private String opis;

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getNazwa() { return nazwa; }
    public void setNazwa(String nazwa) { this.nazwa = nazwa; }
    public String getOpis() { return opis; }
    public void setOpis(String opis) { this.opis = opis; }
}

Modyfikacja do postaci encji, możliwej do wykorzystania przez JPA do obsługi danych zawartych w tabeli Grupy polega na opisaniu klasy metainformacjami – adnotacjami z pakietu javax.persistence. Gotowa klasa przedstawia się następująco:

package eu.doniec.piotr.persistence;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQuery;
import javax.persistence.Table;

@Entity
@NamedQuery(
    name="findAllGroups",
    query="SELECT g FROM Grupa g"
)
@Table(name="GRUPY")
public class Grupa implements Serializable {

    @Id @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String nazwa;
    private String opis;

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getNazwa() { return nazwa; }
    public void setNazwa(String nazwa) { this.nazwa = nazwa; }
    public String getOpis() { return opis; }
    public void setOpis(String opis) { this.opis = opis; }
}

Podobnie sytuacja wygląda z klasą Studenta, choć tu sytuacja jest trochę inna. Struktura bazy danych wymaga aby tabela STUDENCI posiadała ograniczenie FOREIGN_KEY na dodatkowe pole GRUPA_ID. W takiej sytuacji w ramach encji Student umieszczamy odwołanie do encji Grupa. Właściwość ta jest dodatkowo oznaczona adnotacją @ManyToOne oznaczającą właśnie że wielu studentów może przynależeć do jednej grupy.

package eu.doniec.piotr.persistence;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.persistence.ManyToOne;
import javax.persistence.JoinColumn;

@Entity
@NamedQuery(
    name="findAllStudents",
    query="SELECT s FROM Student s"
)
@Table(name="STUDENCI")
public class Student implements Serializable {
    @Id @GeneratedValue(strategy = GenerationType.AUTO)
    private Long nr_indeksu;

    private String imie;
    private String nazwisko;

    @ManyToOne
    private Grupa grupa;

    public Long getNr_indeksu() { return nr_indeksu; }
    public void setNr_indeksu(Long nr_indeksu) { this.nr_indeksu=nr_indeksu; }
    public String getImie() { return imie; }
    public void setImie(String imie) { this.imie = imie; }
    public String getNazwisko() { return nazwisko; }
    public void setNazwisko(String nazwisko) { this.nazwisko = nazwisko; }
    public Grupa getGrupa() { return grupa; }
    public void setGrupa(Grupa grupa) { this.grupa = grupa; }
}

Encje są zdefiniowane, pozostało jeszcze je wykorzystać. W tym celu powstanie servlet, który wyświetli nr indeksu, nazwisk i przydział studenta do grupy. W celu wykorzystania stworzonych obiektów trzeba utworzyć obiekt EntityManager’a, a raczej „wstrzyknąć” go do aplikacji – uzyskuje się to annotacją @PersistenceContext. Utworzony w ten sposób EntityManager jest zarządzany przez kontener aplikacji tzw. container-managed. Sensowne wydaje się wstrzyknięcie go w klasie implementującej ServletContextListener i zapisanie w kontekście servletu, w ten sposób łatwo będzie się do niego dostać:

package eu.doniec.piotr.listeners;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import javax.servlet.ServletContext;

import javax.persistence.PersistenceContext;
import javax.persistence.EntityManager;

@WebListener()
public class ContextListener implements ServletContextListener {

    @PersistenceContext
    private EntityManager em;

    private ServletContext context;

    public void contextInitialized(ServletContextEvent sce) {
        context = sce.getServletContext();
        context.setAttribute("EntityManager", em);
    }

    public void contextDestroyed(ServletContextEvent sce) {
        context.removeAttribute("EntityManager");
    }
}

Na tym etapie, pozostało już tylko stworzenie serwletu i konfiguracja połączenia z bazą danych. Ostatni, prymitywny fragment kodu wypisuje na ekran nr indeksu, nazwisko i nazwę grupy do której zapisany jest student.

package eu.doniec.piotr.servlets;

import eu.doniec.piotr.persistence.Student;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import javax.persistence.EntityManager;
import javax.persistence.Query;

@WebServlet(name="studenci", urlPatterns={"/studenci"})
public class Studenci extends HttpServlet {

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        try {
            EntityManager em = (EntityManager)getServletContext().getAttribute("EntityManager");
            Query q = em.createNamedQuery("findAllStudents");

            out.println("<html>");
            out.println("<head>");
            out.println("<title>Servlet studenci</title>");
            out.println("</head>");
            out.println("<body>");
            out.println("<h1>Servlet studenci at " + request.getContextPath () + "</h1>");

            out.println("<table>");
            out.println("<tr><th>Numer indeksu</th><th>Nazwisko</th><th>Grupa</th></tr>");

            List studenci =  q.getResultList();
            for (Iterator iter = studenci.iterator(); iter.hasNext();) {
                Student s = (Student) iter.next();
                out.println("<tr>");
                out.println("<td>" + s.getNr_indeksu() +"</td>");
                out.println("<td>" + s.getNazwisko() + "</td>");
                out.println("<td>" + s.getGrupa().getNazwa() +"</td>");
                out.println("</tr>");
            }

            out.println("</body>");
            out.println("</html>");
        } finally {
            out.close();
        }
    } 

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        processRequest(request, response);
    }
}

Plik persistence.xml:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
  <persistence-unit name="baza-danych-nauczyciela-pu" transaction-type="JTA">
    <provider>oracle.toplink.essentials.PersistenceProvider</provider>
    <jta-data-source>jdbc/bazanauczyciela</jta-data-source>
  </persistence-unit>
</persistence>

Sposób stworzenie źródła danych dla Oracle pod Glassfish wystarczająco dobrze opisany jest tu: http://technology.amis.nl/blog/1276/configuring-a-oracle-datasource-on-glassfish.

Program('main.cpp')

Na Windows domyślnie zostanie wykorzystany (o ile dostępny) kompilator Microsoftu. Jeśli jednak chcemy użyć g++, wystarczy dopisać jeszcze jedną linię:

env = Environment(tools = ['mingw'], CC = 'gcc', CCFLAGS = '-O2')
env.Program('main.cpp')

Piewsze lody przełamane, kolejne próby będą sprawdzały łatwość dołączania zewnętrzych bibliotek jak boost czy qt.

Na wszelki, skopiowany kod poprawki poniżej:

— ZSI-2.1-a1/ZSI/ServiceContainer.py 2007-08-08 00:56:37.000000000 +0200
+++ ServiceContainer.py 2008-06-19 13:50:11.000000000 +0200
@@ -5,6 +5,7 @@

import urlparse, types, os, sys, cStringIO as StringIO, thread,re
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
+from SocketServer import ThreadingMixIn
from ZSI import ParseException, FaultFromException,
FaultFromZSIException, Fault
from ZSI import _copyright, _seqtypes, _get_element_nsuri_name, resolvers
from ZSI import _get_idstr
@@ -30,6 +31,7 @@
SimpleWSResource
SOAPRequestHandler
ServiceContainer
+ ThreadedServiceContainer
„”"
class NoSuchService(Exception): pass
class UnknownRequestException(Exception): pass
@@ -141,12 +143,16 @@
return SendFault(FaultFromException(e, 0, sys.exc_info()[2]), **kw)

-def AsServer(port=80, services=()):
+def AsServer(port=80, services=(), threaded=False):
”’port –
services — list of service instances
+ threaded — in modo multithread ?
”’
address = (”, port)
- sc = ServiceContainer(address, services)
+ if threaded:
+ sc = ThreadedServiceContainer(address, services)
+ else:
+ sc = ServiceContainer(address, services)
sc.serve_forever()

@@ -467,6 +473,11 @@
def removeNode(self, url):
self._nodes.removeNode(url)

+class ThreadedServiceContainer(ThreadingMixIn, ServiceContainer):
+ ”’Multithreaded version of ServiceContainer.
+ ”’
+ pass
+

class SimpleWSResource(ServiceSOAPBinding):

# gry - lista skladajaca sie z list reprezentujacych gre. Kazda reprezentacja
# gry to kolejna lista zaiwerajaca ilosc 'kijkow' na kolejnych stosach
def graj(gry):
    sg = (0, 0, 1, 1, 2, 2, 3)
    for gra in gry:
        g = []
        reszty = []
        for stos in gra:
            reszta = int(stos)%7
            g.append(sg[reszta])
            reszty.append(reszta)
        wynik = reduce(lambda x,y: x^y, g)

        if wynik :
            print "Julia wins."
        else :
            print "Robert wins.\n"

Lekki problem pojawia się przy ustalaniu ruchu wygrywającego. Nie wiem czy istnieje jakieś szybsze rozwiązanie niż takie trochę brute-force’owe która ja wykorzystałem. Polega ono na stwierdzeniu na jakiej pozycji ( wygrywającej czy przegrywającej ) znalazł by się gracz gdyby nie było jednego stosiku, a następnie obliczeniu czy da się odjąć taką liczbę patyczków żeby zostawić przeciwnika na pozycji przegrywającej.
Dodatkowo oprócz wskazania ruchu wygrywającego należy wskazać ten podczas którego bierze się najwięcej patyczków ze stosu o najmniejszym numerze, co w lekki sposób komplikuje sprawę.:

        stos_wygrywajacy = 0;
        licznik = 0
        blokada_5 = False
        blokada_3 = False

        # odwrocenie list, sprawdzanie od konca
        gra_rev = gra[:]
        gra_rev.reverse()

        g_rev = g[:]
        g_rev.reverse()

        reszty.reverse()
        for reszta in reszty:
            # lista reszt bez kolejnych stosow
            tmpr = reszty[:]
            tmpr.pop(licznik)

            # xor wartosci f. Sprague-Grundy'ego
            # bez kolejnych stosow
            tmpg = g_rev[:]
            tmpg.pop(licznik)
            tmpw = reduce(lambda x,y: x^y, tmpg ,0)

            if sg[reszta-5] == tmpw and int(gra_rev[licznik]) >= 5:
                wygrywajacy = 5
                stos_wygrywajacy = len(reszty) - licznik
                blokada_5 = True
            elif sg[reszta-3] == tmpw and int(gra_rev[licznik]) >= 3 and blokada_5 == False:
                wygrywajacy = 3
                stos_wygrywajacy = len(reszty) - licznik
                blokada_3 = True
            elif sg[reszta-2] == tmpw and int(gra_rev[licznik]) >= 2 and blokada_5 == False and blokada_3 == False:
                wygrywajacy = 2
                stos_wygrywajacy = len(reszty) - licznik

            licznik += 1

Jeśli ktoś zna szybsze rozwiązanie chętnie je przeanalizuję
Zaznaczam, że nie dam sobie głowy uciąć że algorytm jest poprawny, bo nie ma już możliwości zgłoszenia rozwiązania – upłynęły terminy.

EDIT:
Lekko poprawiona wersja, działa trochę szybciej, natomiast i tak nie umożliwia zdobycia maximum punktów. Jesli nie ma jakiejś sztuczki na ruch wygrywający, a podejrzewam że coś jest, to lepiej zakodzić to w C…

        stos_wygrywajacy = 0
        blokada_3 = False
        blokada_2 = False
        licznik = 0
        for reszta in reszty :
            tmpg = g[:]
            tmpg.pop(licznik)
            tmpw = reduce(lambda x,y: x^y, tmpg, 0)

            if sg[reszta-5] == tmpw and int(gra[licznik]) >= 5:
                wygrywajacy = 5
                stos_wygrywajacy = licznik + 1
                break
            elif sg[reszta-3] == tmpw and int(gra[licznik]) >= 3 and blokada_3 == False:
                wygrywajacy = 3
                stos_wygrywajacy = licznik + 1
                blokada_3 = True
            elif sg[reszta-2] == tmpw and int(gra[licznik]) >= 2 and blokada_3 == False and blokada_2 == False:
                wygrywajacy = 2
                stos_wygrywajacy = licznik + 1
                blokada_2 = True
            licznik += 1