Prikaz objav z oznako Koda. Pokaži vse objave
Prikaz objav z oznako Koda. Pokaži vse objave

sobota, 5. november 2011

Avtomatizacija

Še ne tako dolgo nazaj sem pisal o Chromu, zaznamkih, aplikacijah oz. o hibridu. V zadnji različici (v15) so odstranili zavihek z zaznamki a še vedno lahko potegnemo zaznamek med aplikacije iz vrstice z zaznamki. A situacija ni idealna - ikona je majhna (favicon) ostalo je belina in naziv ni ustrezen, običajno je kar celoten naslov.
Problem lahko rešimo z izdelavo hibrida ampak to ni preveč praktično. Potrebno je poznati postopek, sintakso in semantiko manifesta. Poleg tega pa je potrebno še ročno zmanjšati sliko. Takšen proces kar kriči po avtomatizaciji.
Izdelal sem preprosto namizno WPF aplikacijo po vzorcu MVVM z uporabo vmesnika ICommand. Takšen način popolnoma loči predstavitveni nivo od poslovne logike. V datoteki za grafičnim vmesnikom se nahajajo samo inicializacije pa še to ni potrebno, če imajo konstruktorje brez parametrov. Aplikacija pa je zlepljena z Ninject-om (Dependency injection framework).

Vmesnik in koda zadaj.
Aplikacija najprej prebere datoteko z zaznamki, ki se skriva v mapi kjer je nameščen Google Chrome. Zaznamki so zapisani v JSON obliki in jih je potrebno deserializirati v objektni model. Model si lahko generiramo s pomočjo pretvornika json2csharp. Dobljeni model lahko potem optimiziramo in pobrišemo polja, ki nas ne zanimajo. Tako dobimo enostavnejši podatkovni model.

Branje zaznamkov.
Za pretvorbo lahko izberemo samo en zaznamek naenkrat. V nadaljevanju poljubno dopolnimo zaznamek in izberemo sliko - slika je obvezna!

Urejanje in izbira slike.
Aplikacija nam sliko pretvori v ikono velikosti 128x128px in potem generira datoteko z "aplikacijo".

Namestitev "aplikacije".
Na namizju se ustvari mapa v kateri je *.crx in *.pem. V primeru, da se nam ni prikazalo potrditveno okno za namestitev še enkrat potrdimo naslov v naslovni vrstici (izberemo in pritisnemo ENTER).  Obnašanje se razlikuje glede na kanal (Stable, Beta, Dev, Canary). Možno je, da deluje tudi preprosto vlečenje datoteke *.crx v okno brskalnika.

Končni rezultat.
Spletne strani postajajo aplikacije, meja se briše. Zato naj bodo lepo pomešane med seboj. Pogrešam pa možnost izdelave map in enostavnega urejanja. V tem primeru bi lahko vrstico z zaznamki kar umaknil.

torek, 5. april 2011

Javin naštevni tip – Enum

Redko kaj napišem pa čeprav imam kar nekaj idej – lenoba pač. Nekatere ideje so že vsaj delno realizirane a do objave tukaj bi bilo potrebno vložiti še nekaj dela. Tokrat bom pisal o Javinem naštevnem tipu in njegovi uporabi.

Naštevni tip v Javi je dosti močnejši kot pa v ostalih programskih jezikih (C, C++, C# …). Precej so podobni razredom. Lahko imajo konstruktor, metode, spremenljivke in implementirajo vmesnike. Pred časom sem jih uporabil za izdelavo grafičnega vmesnika za vnos virov(referenc) pri člankih ipd. Cilj je bil narediti karseda enostavno strukturo teh virov, ki bo enostavna za vzdrževanje in pregledna. Za začetek je potrebno definirat grafične gradnike, ki se bodo prikazali na zaslonu. Vnosna polja, izbira datuma, kombinirano polje ipd.

To naredimo z naštevnim tipom, ki mu definiramo abstraktno metodo, ki vrača Swing komponento. Pri vsakem definiranem tipu to metodo prepišemo, da nam vrača ustrezno komponento. Definiramo si vse različne tipe komponent in njihove izpeljanke, ki jih bomo kasneje rabili.
package javaenumblog.sourcecontrol;

import java.awt.Component;
import javax.swing.JComboBox;
import javax.swing.JTextArea;
import javax.swing.JTextField;

//define all kind of types/components with contents and variations

public enum Type {

    TEXTFIELD {

        @Override
        public Component getComponent() {
            return new JTextField(30);
        }
    },INITIAL
    {

        public Component getComponent()
        {
            return new JTextField(5);
        }
    },
    AUTHORS {

        @Override
        public Component getComponent() {
            JTextArea textArea = new JTextArea(1, 40);
            textArea.setLineWrap(true);
            return textArea;
        }
    },
    EDUCATION {

        @Override
        public Component getComponent() {
            return new JComboBox(new Object[]{
                        "B.Sc", "M.Sc.", "PHD"
                    });
        }
    };

    public abstract Component getComponent();
}
V naslednjem koraku definiramo vse različne tipe in njihove nazive. Kasneje jih bomo uporabili za sestavljanje vseh različnih vrst referenc. Definiramo si dve spremenljivki in pripadajoči metodi, ki vračata njuno vrednost. Konstruktor pa nam predpisuje ustrezno obliko naštevnega tipa. Za lepšo kodo statično uvozimo imensko področje. To nam omogoča direktno delo s tipi brez kvalifikatorja.
package javaenumblog.sourcecontrol;
//staticly imported enums may be used without qualification
import static javaenumblog.sourcecontrol.Type.*;
//define fields (title and type)
public enum SourceTypes {

    articleTitle("Article title:", TEXTFIELD),
    authors("Authors:", AUTHORS),
    publicationTitle("Publication title:", TEXTFIELD),
    year("Year:", INITIAL),
    initials("Initials:", INITIAL),
    obtainedUrl("Page URI:", TEXTFIELD),
    education("Education:", EDUCATION),;
    protected String label;
    protected Type type;

    SourceTypes(String label, Type type) {
        this.label = label;
        this.type = type;
    }

    public String getLabel() {
        return label;
    }

    public Type getType() {
        return type;
    }
}
V naslednjem koraku pa že definiramo vse različne oblike referenc na vire. Sestavimo jih iz polj, ki smo jih določili zgoraj. Vsaki referenci pa dodamo tudi naziv. To naredimo na podoben način kot smo zgoraj le da tukaj potrebujemo polje vseh potrebnih vnosnih polj. Prepišemo pa tudi metodo toString() tako, da nam bo vračala samo oznako. Pravtako statično uvozimo naštevni tip za čistejšo kodo.
package javaenumblog.sourcecontrol;

import static javaenumblog.sourcecontrol.SourceTypes.*;

//construct sources you need from sourceTypes
public enum Sources {

    WEBARTICLE("Web magazine - article", new SourceTypes[]{
authors, articleTitle, publicationTitle, year, obtainedUrl
}), ARTICLE("demo article", new SourceTypes[]{
initials, education, articleTitle
});
//and more...
    protected String label;
    protected SourceTypes[] sourceTypes;

    private Sources(String title, SourceTypes[] sourceTypes) {
        this.label = title;
        this.sourceTypes = sourceTypes;
    }

    public SourceTypes[] getSourceTypes() {
        return sourceTypes;
    }

    public String getLabel() {
        return label;
    }

    @Override
    public String toString() {
        return label;
    }
}
Sedaj je potrebno še napisati razred, ki bo izbrane komponente razporedil na grafični vmesnik in kasneje shranil ustrezne podatke k pripadajoči komponenti. Logiko poskušamo karseda ločiti od grafičnega vmesnika zato v konstruktor dobimo samo referenco na JPanel komponento. Na njo bomo izrisali vmesnik za vnos. V metodi za generiranje vmesnika pa se sprehodimo skozi vse gradnike, ki jih zahteva referenca in jih izrisujemo na panel v dvojicah (naziv, komponenta). Ker jih dodajamo kar absolutno moramo vsakemu določiti tudi meje preden jih dodamo. Ne smemo pozabiti tudi na ustrezne odmike. Da pa lahko za vsako polje vemo k kateri komponenti spada pa jih sproti dodajamo še v povezan seznam (LinkedHashMap) – vrstni red je pomemben! Seveda pa moramo napisati še metodo, ki nam bo nove vrednosti tudi prebrala iz ustreznih komponent. Tukaj se sprehodimo čez naš seznam dvojic (naziv, komponenta) in glede na tip komponente preberemo njeno vrednost. To naredimo kar na takšen način, ki sem ga že opisal TUKAJ. V tem primeru lastnosti in vrednosti izpišemo kar na standardni izhod.
package javaenumblog.sourcecontrol;
import java.awt.Component;
import java.util.LinkedHashMap;
import javax.swing.JComboBox;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JTextField;
public class GUIGenerator {
    private JPanel panel = null;
    private LinkedHashMap<String, Component> mapComponent = new LinkedHashMap<String, Component>();
    private enum Classes {
        JTextField, JTextArea, JComboBox
    };

    public GUIGenerator(JPanel panel) {
        this.panel = panel;
    }

    public void generateInput(Sources types) {
        mapComponent.clear();
        if (types != null) {
            panel.removeAll();
            int Y = 20;
            for (SourceTypes sourceTypes : types.getSourceTypes()) {
                String labelTag = sourceTypes.getLabel();
                JLabel label = new JLabel(labelTag);
                label.setBounds(20, Y, label.getPreferredSize().width, label.getPreferredSize().height);
                Component component = sourceTypes.getType().getComponent();
                panel.add(label);
                component.setBounds(200, Y, component.getPreferredSize().width, component.getPreferredSize().height);
                panel.add(component);
                mapComponent.put(sourceTypes.name(), component);
                Y += 40;
            }
            panel.repaint();
            panel.revalidate();
        }
    }

    public void generateOutput() {
        for (String label : mapComponent.keySet()) {
            Component component = mapComponent.get(label);
            String sout = "Property: " + label + " ; value: ";
            String className = component.getClass().getSimpleName();
            switch (Classes.valueOf(className)) {
                case JTextField:
                    sout += ((JTextField) component).getText();
                    break;
                case JTextArea:
                    sout += ((JTextArea) component).getText();
                    break;
                case JComboBox:
                    sout += ((JComboBox) component).getSelectedItem();
                    break;
            }
            System.out.println(sout);
        }
    }
}
V zadnjem koraku pa še sestavimo enostaven grafični vmesnik, ki bo glede na izbiro v kombiniranem polju izrisal pripadajoč grafični vmesnik. Kombinirano polje vežemo na seznam, ki ga napolnimo iz naštevnega tipa. Naredimo nov objekt generatorja in mu dodamo panel. Ob spremembi izbire v kombiniranem polju preberemo za katero vrsto reference gre in izrišemo ustrezen vmesnik. Pri izpisu pa samo pokličemo metodo, ki smo jo prej napisali.



Pri zagonu programa nas pričaka podoben zaslon kot spodaj. V kombiniranem polju sta na voljo dve različni referenci, ki generirata različna vnosna polja.


S klikom na gumb Print pa se na standardni izhod izpišejo nazivi in vrednosti kot smo določili pri posamezni vrsti reference.

ponedeljek, 4. oktober 2010

Iz C# v F# in nazaj

Po dolgem času sem spet zbral malo volje da nekaj spišem. Šlo bo za zadevo, ki sem jo sprogramiral že pred časom, da sem si malo ogledal C# 4.0. Nekaj F#-a in paralelizacije ter medsebojne uporabe knjižnic.

Kontekst
Računanje fakultete. Gre za matematično funkcijo, ki je zmnožek vseh manjših števil, vključno z n -
(5! = 1 * 2 * 3 * 4 * 5 = 120). Funkcije za računanje fakultet sem napisal na več načinov – za primerjavo.

F#
Gre za funkcijski programski jezik s podporo objektnemu programiranju, ki temelji na .NET platformi. Primeren je za kompleksne algoritme, simulacije, analize, matematične izračune, paralelizacijo, podatkovno rudarjenje, umetno inteligenco...

Implementacija


Rekurzivno funkcijo za izračun fakultete sem dal v posebno knjižnico, da ni bilo krožne reference. To funkcijo kličemo potem iz F#. Uporabiti je potrebno BigInteger saj rezultati kmalu postanejo ogromni.
using System.Numerics;

namespace FactorialLibrary
{
    public struct RecursiveFactorial
    {
        public static BigInteger FactorialRecursive(BigInteger number)
        {
            return number > 1 ? number * FactorialRecursive(number - 1) : 1;
        }
    }
}
F# modul z rekurzivno, iterativno in eksotično funkcijo za izračun fakultete. Spodnja funkcija pa je klic funkcije iz zgoraj omenjene C# knjižnice.
module FactorialFSharpLibrary
open FactorialLibrary

let factorialExotic(n) = Seq.fold ( * ) 1I [1I .. n];;

let rec factorialRecursive(n) =
    if n < 1I then 1I
    else n * factorialRecursive (n - 1I);;

let factorialIterative(n:bigint) = 
    let mutable result = 1I
    for i=1 to (int)n do
       result <- result * bigint(i)
    done
    result;;

let factorialRecursiveCSharp(n) =
    RecursiveFactorial.FactorialRecursive(n);;
V C# strukturi pa imamo iterativno in paralelno funkcijo za izračun fakultete. Prav tako pa kličemo tudi vse zgoraj napisane funkcije.
public struct Factorial
    {
        public static BigInteger Number { get; set; }

        public static BigInteger FactorialIterative()
        {
            var fact = new BigInteger(1);
            for (var i = 1; i <= Number; i++) { fact *= i; }
            return fact;
        }

        public static BigInteger FactorialIParallel()
        {
            var fact = new BigInteger(1);
            Parallel.For(1, (long)Number + 1, i => { fact *= i; });
            return fact;
        }

        public static BigInteger FactorialFSharpExotic()
        {
            return FactorialFSharpLibrary.factorialExotic(Number);
        }

        public static BigInteger FactorialFSharpRecursive()
        {
            return FactorialFSharpLibrary.factorialRecursive(Number);
        }

        public static BigInteger FactorialFSharpIterative()
        {
            return FactorialFSharpLibrary.factorialIterative(Number);
        }

        public static BigInteger FactorialRecursiveOverFSharp()
        {
            return FactorialFSharpLibrary.factorialRecursiveCSharp(Number);
        }
    }
V glavnem programu samo pokličemo vse metode in izpišemo rezultate. Čas izvajanja posamezne metode tudi izmerimo.
struct FactorialExamples
    {
        private const string Print = ":\n{0}";

        public delegate BigInteger ExecuteMethod();

        public static void MeasureMethod(string printLine, ExecuteMethod method)
        {
            var timer = Stopwatch.StartNew();
            var result = method();
            timer.Stop();
            Console.WriteLine(string.Format(printLine + Print, result) + "\ntime: " + timer.ElapsedMilliseconds + "ms");
        }

        public static void Main()
        {
            Factorial.Number = 100;
            Console.WriteLine("Factorial of {0}", Factorial.Number);
            MeasureMethod("recursive C# over F#", Factorial.FactorialRecursiveOverFSharp);
            MeasureMethod("iterative", Factorial.FactorialIterative);
            MeasureMethod("parallel", Factorial.FactorialIParallel);
            MeasureMethod("exotic F#", Factorial.FactorialFSharpExotic);
            MeasureMethod("recursive F#", Factorial.FactorialFSharpRecursive);
            MeasureMethod("iterative F#", Factorial.FactorialFSharpIterative);
            Console.ReadKey();
        }
    }
Rezultati fakultete števila 200 in čas izvajanja.

Testiranje
Vse funkcije tudi testiramo z Unit testi. Zgoraj so konstante za obvestila o napakah, spodaj pa klici vseh metod in primerjava njihovih rezultatov s pravilnim. Metode testiramo z različnimi argumenti.
[TestClass]
    public class TestFactorial
    {

        #region Printout fields
        private const string Recursive = "Error in recursive function";
        private const string Iterative = "Error in iterative function";
        private const string Parallel = "Error in parallel function";
        private const string ExoticF = "Error in exotic F# function";
        private const string IterativeF = "Error in iterative F# function";
        private const string RecursiveF = "Error in recursive F# function";
        #endregion

        private static void MethodRun(BigInteger parameter, BigInteger expectedResult)
        {
            Factorial.Number = parameter;
            var actual = Factorial.FactorialRecursiveOverFSharp();
            Assert.AreEqual(expectedResult, actual, Recursive);
            actual = Factorial.FactorialIterative();
            Assert.AreEqual(expectedResult, actual, Iterative);
            actual = Factorial.FactorialIParallel();
            Assert.AreEqual(expectedResult, actual, Parallel);
            actual = Factorial.FactorialFSharpExotic();
            Assert.AreEqual(expectedResult, actual, ExoticF);
            actual = Factorial.FactorialFSharpIterative();
            Assert.AreEqual(expectedResult, actual, IterativeF);
            actual = Factorial.FactorialFSharpRecursive();
            Assert.AreEqual(expectedResult, actual, RecursiveF);
        }

        #region Test Methods
        [TestMethod]
        public void TestFactorialsFor0()
        {
            MethodRun(0, 1);
        }

        [TestMethod]
        public void TestFactorialsFor1()
        {
            MethodRun(1, 1);
        }

        [TestMethod]
        public void TestFactorialsFor10()
        {
            MethodRun(10, 3628800);
        }

        [TestMethod]
        public void TestFactorialsFor20()
        {
            MethodRun(20, 2432902008176640000);
        }
        #endregion

    }
}
Rezultati testa - vsi testi so uspešni.
Za konec pa še metrika kode za C# projekte v tej rešitvi.

petek, 10. september 2010

Java in String switch

Končno mi je uspelo usposobiti tudi barvanje kode tukaj na blogu tako, da bom lahko lepše objavljal izrezke kode. Pa poskusimo.
Kot je znano Java 6 ne omogoča uporabe nizov (Stringov) v switch stavkih. Omogoča samo primerjavo Integer-jev, char-ov in enum-ov. S slednjimi pa si lahko pomagamo pri implementaciji želenega switch stavka za String-e. JDK7 sicer obljublja to že nekaj časa ampak bomo po vsej verjetnosti zadevo ogledali šele nekje v sredini leta 2011 (plan B). Ta JDK izdaja pa bo vsebovala samo del predvidenih specifikacij za JDK7. Kompleten paket je predviden za izdajo nekje ob koncu leta 2012 kot JDK8 (plan A).
No pa se vrnimo k namešmu problemu. Recimo, da hočemo implementirati switch stavek, ki nam bo vračal vrednosti za poljubne lastnosti grafičnih komponent. Zaradi lepše implementacije bomo te vrednosti vračali kar kot String-e.
Kot rečeno si bomo pomagali z naštevnimi tipi (enumi). Naštejmo imena komponent (velike črke) s katerimi bomo kasneje preverjali za kateri tip komponente gre. Najlažje s kratkimi imeni. Dodajmo pa še nek tip, ki nam bo predstavljal vse ostalo kar ne bo možno kasneje pretvorit.
/*
     * Enum with our simple class names
     */
    private enum ClassesEnum {
        TEXTFIELD, JCOMBOBOX, JTEXTAREA, JLABEL, JLIST, OTHER
    };
Zdaj pa definirajmo še našo metodo, ki bo vračala vrednost glede na tip komponente. Kratko ime razreda našega argumenta (komponente) pretvorimo v ustrezen naštevni tip, ki smo ga prej definirali. Seveda moramo ta imena v naštevnem tipu natančno definirati, mi smo jih z velikimi črkami.
/*
     * Returns value of given component
     */
    private static String getValue(Component component) {
        //get simple class name
        String className = component.getClass().getSimpleName().toUpperCase();
        //try to convert into enum
        try {
            ClassesEnum.valueOf(className);
        } catch (IllegalArgumentException e) {
            className = ClassesEnum.OTHER.name();
        }
        //convert to enum an get related property
        switch (ClassesEnum.valueOf(className)) {
            case JTextArea:
                return ((JTextArea) component).getText();
            case TextField:
                return ((TextField) component).getText();
            case JComboBox:
                return ((JComboBox) component).getSelectedItem().toString();
            case JLabel:
                return ((JLabel) component).getText();
            case JList:
                return ((JList) component).getSelectedValue().toString();
            default:
                return "Component is not defined!";
        }
    }
No zdaj pa še preverimo našo metodo z različnimi argumenti.
//Our test method
public static void main(String[] args) {
         // Test data
        JLabel label = new JLabel("This is label!");
        TextField textField = new TextField("This is text field!");
        JTextArea textArea = new JTextArea("This is text area!");
        JComboBox jComboBox = new JComboBox(
                    new Object[]{"This is selected item in JComboBox!"});
        jComboBox.setSelectedIndex(0);
        JList list = new JList(new Object[]{"This is selected item in JList!"});
        list.setSelectedIndex(0);
        Button button = new Button("Not defined!");

        /*
         * Test output
         */
        System.out.println(getValue(label));
        System.out.println(getValue(textField));
        System.out.println(getValue(textArea));
        System.out.println(getValue(jComboBox));
        System.out.println(getValue(list));
        System.out.println(getValue(button));
    }
To je trenutno najboljša rešitev, če ne želimo čakat na JDK7. Omenimo pa lahko še eno rešititev.
HashMap<String, Integer> map = new HashMap<String, Integer>() {
            {
                put("JTEXTAREA", 0);
                put("TEXTFIELD", 1);
                //...
            }
        };
        String testString = textArea.getClass().getSimpleName().toUpperCase();
        switch ((Integer) map.get(testString)) {
            case 0:
                System.out.println("This is text area!");
        }
Pa še končni rezultat.