Category: Development

Development stories

XmlSerializable Generic Dictionary

I need to use generic dictionary on both JSON and XML serialization.


using System;
using System.Collections.Generic;
using System.Text;
using System.Xml.Serialization;
using System.Xml.Schema;
using System.Xml;

namespace Rubik.Staging
{
[XmlSchemaProvider(“GetInternalSchema”)]
public class SerializableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, IXmlSerializable
{
#region IXmlSerializable Members

private const string ns = “http://www.rubik.com.tr/staging”;

public static XmlQualifiedName GetInternalSchema(XmlSchemaSet xs)
{
bool keyIsSimple = (typeof(TKey).IsPrimitive || typeof(TKey) == typeof(string));
bool valueIsSimple = (typeof(TValue).IsPrimitive || typeof(TValue) == typeof(string));

XmlSchemas schemas = new XmlSchemas();

XmlReflectionImporter importer = new XmlReflectionImporter(ns);
importer.IncludeType(typeof(TKey));
importer.IncludeType(typeof(TValue));

XmlTypeMapping keyMapping = importer.ImportTypeMapping(typeof(TKey));
XmlTypeMapping valueMapping = importer.ImportTypeMapping(typeof(TValue));

XmlSchemaExporter exporter = new XmlSchemaExporter(schemas);

if(!keyIsSimple)
exporter.ExportTypeMapping(keyMapping);
if(!valueIsSimple)
exporter.ExportTypeMapping(valueMapping);

XmlSchema schema = (schemas.Count == 0 ? new XmlSchema() : schemas[0]);

schema.TargetNamespace = ns;
XmlSchemaComplexType type = new XmlSchemaComplexType();
type.Name = “DictionaryOf” + keyMapping.XsdTypeName + “And” + valueMapping.XsdTypeName;
XmlSchemaSequence sequence = new XmlSchemaSequence();
XmlSchemaElement item = new XmlSchemaElement();
item.Name = “Item”;

XmlSchemaComplexType itemType = new XmlSchemaComplexType();
XmlSchemaSequence itemSequence = new XmlSchemaSequence();

XmlSchemaElement keyElement = new XmlSchemaElement();

keyElement.Name = “Key”;
keyElement.MaxOccurs = 1;
keyElement.MinOccurs = 1;

XmlSchemaComplexType keyType = new XmlSchemaComplexType();
XmlSchemaSequence keySequence = new XmlSchemaSequence();
XmlSchemaElement keyValueElement = new XmlSchemaElement();
keyValueElement.Name = keyMapping.ElementName;
keyValueElement.SchemaTypeName = new XmlQualifiedName(keyMapping.XsdTypeName, keyMapping.XsdTypeNamespace);
keyValueElement.MinOccurs = 1;
keyValueElement.MaxOccurs = 1;
keySequence.Items.Add(keyValueElement);
keyType.Particle = keySequence;
keyElement.SchemaType = keyType;
itemSequence.Items.Add(keyElement);

XmlSchemaElement valueElement = new XmlSchemaElement();

valueElement.Name = “Value”;
valueElement.MaxOccurs = 1;
valueElement.MinOccurs = 1;

XmlSchemaComplexType valueType = new XmlSchemaComplexType();
XmlSchemaSequence valueSequence = new XmlSchemaSequence();
XmlSchemaElement valueValueElement = new XmlSchemaElement();
valueValueElement.Name = valueMapping.ElementName;
valueValueElement.SchemaTypeName = new XmlQualifiedName(valueMapping.XsdTypeName, valueMapping.XsdTypeNamespace);
valueValueElement.MinOccurs = 1;
valueValueElement.MaxOccurs = 1;
valueSequence.Items.Add(valueValueElement);
valueType.Particle = valueSequence;
valueElement.SchemaType = valueType;
itemSequence.Items.Add(valueElement);
itemType.Particle = itemSequence;
item.SchemaType = itemType;
sequence.Items.Add(item);
type.Particle = sequence;
schema.Items.Add(type);

xs.XmlResolver = new XmlUrlResolver();
xs.Add(schema);

return new XmlQualifiedName(type.Name, ns);
}

public void ReadXml(System.Xml.XmlReader reader)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));

bool wasEmpty = reader.IsEmptyElement;
reader.Read();

if (wasEmpty)
return;

while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
reader.ReadStartElement(“Item”);

reader.ReadStartElement(“Key”);
TKey key = (TKey)keySerializer.Deserialize(reader);
reader.ReadEndElement();

reader.ReadStartElement(“Value”);
TValue value = (TValue)valueSerializer.Deserialize(reader);
reader.ReadEndElement();

this.Add(key, value);

reader.ReadEndElement();

reader.MoveToContent();
}

reader.ReadEndElement();
}

public void WriteXml(System.Xml.XmlWriter writer)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));

foreach (TKey key in this.Keys)
{
writer.WriteStartElement(“Item”);

writer.WriteStartElement(“Key”);
keySerializer.Serialize(writer, key);
writer.WriteEndElement();

writer.WriteStartElement(“Value”);
TValue value = this[key];
valueSerializer.Serialize(writer, value);
writer.WriteEndElement();

writer.WriteEndElement();
}
}

#endregion

#region IXmlSerializable Members

public XmlSchema GetSchema()
{
return null;
}

#endregion
}

}

Integrating svn with trac on windows.

After many misleads, i put many different files into work.
Here is the post-commit solution to integration on windows.
I suggest that add svn bin and python paths to enviroment.

post-commit.bat

%~dp0\post-commit-hook.cmd %1 %2

post-commit-hook.cmd

@ECHO OFF
::
:: Trac post-commit-hook script for Windows
::
:: Contributed by markus, modified by cboos.
:: Usage:
::
:: 1) Insert the following line in your post-commit.bat script
::
:: call %~dp0\trac-post-commit-hook.cmd %1 %2
::
:: 2) Check the ‘Modify paths’ section below, be sure to set at least TRAC_ENV

:: ———————————————————-
:: Modify paths here:

:: — this one must be set
SET TRAC_ENV=c:\urtracsite

:: — set if Python is not in the system path
SET PYTHON_PATH=C:\urpythonpath

:: — set to the folder containing trac/ if installed in a non-standard location
SET TRAC_PATH=C:\urtrachome
:: ———————————————————-

:: Do not execute hook if trac environment does not exist
IF NOT EXIST %TRAC_ENV% GOTO :EOF

set PATH=%PYTHON_PATH%;%PATH%
set PYTHONPATH=%TRAC_PATH%;%PYTHONPATH%

SET REV=%2

:: GET THE AUTHOR AND THE LOG MESSAGE
for /F %%A in (‘svnlook author -r %REV% %1’) do set AUTHOR=%%A
for /F “delims==” %%B in (‘svnlook log -r %REV% %1’) do set LOG=%%B

:: CALL THE PYTHON SCRIPT
Python “%~dp0\post-commit-hook.py” -p “%TRAC_ENV%” -r “%REV%” -u “%AUTHOR%” -m “%LOG%”

post-commit-hook.py

#!/usr/bin/env python
# trac-post-commit-hook
# —————————————————————————-
# Copyright (c) 2004 Stephen Hansen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the “Software”), to
# deal in the Software without restriction, including without limitation the
# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
# sell copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# —————————————————————————-

# This Subversion post-commit hook script is meant to interface to the
# Trac (http://www.edgewall.com/products/trac/) issue tracking/wiki/etc
# system.
#
# It should be called from the ‘post-commit’ script in Subversion, such as
# via:
#
# REPOS=”$1″
# REV=”$2″
# LOG=`/usr/bin/svnlook log -r $REV $REPOS`
# AUTHOR=`/usr/bin/svnlook author -r $REV $REPOS`
# TRAC_ENV=’/somewhere/trac/project/’
# TRAC_URL=’http://trac.mysite.com/project/’
#
# /usr/bin/python /usr/local/src/trac/contrib/trac-post-commit-hook \
# -p “$TRAC_ENV” \
# -r “$REV” \
# -u “$AUTHOR” \
# -m “$LOG” \
# -s “$TRAC_URL”
#
# It searches commit messages for text in the form of:
# command #1
# command #1, #2
# command #1 & #2
# command #1 and #2
#
# You can have more then one command in a message. The following commands
# are supported. There is more then one spelling for each command, to make
# this as user-friendly as possible.
#
# closes, fixes
# The specified issue numbers are closed with the contents of this
# commit message being added to it.
# references, refs, addresses, re
# The specified issue numbers are left in their current status, but
# the contents of this commit message are added to their notes.
#
# A fairly complicated example of what you can do is with a commit message
# of:
#
# Changed blah and foo to do this or that. Fixes #10 and #12, and refs #12.
#
# This will close #10 and #12, and add a note to #12.

import re
import os
import sys
from datetime import datetime

from trac.env import open_environment
from trac.ticket.notification import TicketNotifyEmail
from trac.ticket import Ticket
from trac.ticket.web_ui import TicketModule
# TODO: move grouped_changelog_entries to model.py
from trac.util.text import to_unicode
from trac.util.datefmt import utc

try:
from optparse import OptionParser
except ImportError:
try:
from optik import OptionParser
except ImportError:
raise ImportError, ‘Requires Python 2.3 or the Optik option parsing library.’

parser = OptionParser()
parser.add_option(‘-e’, ‘–require-envelope’, dest=’env’, default=”,
help=’Require commands to be enclosed in an envelope. If -e[], ‘
‘then commands must be in the form of [closes #4]. Must ‘
‘be two characters.’)
parser.add_option(‘-p’, ‘–project’, dest=’project’,
help=’Path to the Trac project.’)
parser.add_option(‘-r’, ‘–revision’, dest=’rev’,
help=’Repository revision number.’)
parser.add_option(‘-u’, ‘–user’, dest=’user’,
help=’The user who is responsible for this action’)
parser.add_option(‘-m’, ‘–msg’, dest=’msg’,
help=’The log message to search.’)
parser.add_option(‘-c’, ‘–encoding’, dest=’encoding’,
help=’The encoding used by the log message.’)
parser.add_option(‘-s’, ‘–siteurl’, dest=’url’,
help='(deprecated) the base_url from trac.ini will ‘
‘always be used.’)

(options, args) = parser.parse_args(sys.argv[1:])

if options.env:
leftEnv = ‘\\’ + options.env[0]
rghtEnv = ‘\\’ + options.env[1]
else:
leftEnv = ”
rghtEnv = ”

commandPattern = re.compile(leftEnv + r'(?P[A-Za-z]*).?(?P#[0-9]+(?:(?:[, &]*|[ ]?and[ ]?)#[0-9]+)*)’ + rghtEnv)
ticketPattern = re.compile(r’#([0-9]*)’)

class CommitHook:
_supported_cmds = {‘close’: ‘_cmdClose’,
‘closed’: ‘_cmdClose’,
‘closes’: ‘_cmdClose’,
‘fix’: ‘_cmdClose’,
‘fixed’: ‘_cmdClose’,
‘fixes’: ‘_cmdClose’,
‘addresses’: ‘_cmdRefs’,
‘re’: ‘_cmdRefs’,
‘references’: ‘_cmdRefs’,
‘refs’: ‘_cmdRefs’,
‘see’: ‘_cmdRefs’}

def __init__(self, project=options.project, author=options.user,
rev=options.rev, msg=options.msg, url=options.url,
encoding=options.encoding):
msg = to_unicode(msg, encoding)
self.author = author
self.rev = rev
self.msg = “(In [%s]) %s” % (rev, msg)
self.now = datetime.now(utc)
self.env = open_environment(project)

cmdGroups = commandPattern.findall(msg)

tickets = {}
for cmd, tkts in cmdGroups:
funcname = CommitHook._supported_cmds.get(cmd.lower(), ”)
if funcname:
for tkt_id in ticketPattern.findall(tkts):
func = getattr(self, funcname)
tickets.setdefault(tkt_id, []).append(func)

for tkt_id, cmds in tickets.iteritems():
try:
db = self.env.get_db_cnx()

ticket = Ticket(self.env, int(tkt_id), db)
for cmd in cmds:
cmd(ticket)

# determine sequence number…
cnum = 0
tm = TicketModule(self.env)
for change in tm.grouped_changelog_entries(ticket, db):
if change[‘permanent’]:
cnum += 1

ticket.save_changes(self.author, self.msg, self.now, db, cnum+1)
db.commit()

tn = TicketNotifyEmail(self.env)
tn.notify(ticket, newticket=0, modtime=self.now)
except Exception, e:
# import traceback
# traceback.print_exc(file=sys.stderr)
print>>sys.stderr, ‘Unexpected error while processing ticket ‘ \
‘ID %s: %s’ % (tkt_id, e)

def _cmdClose(self, ticket):
ticket[‘status’] = ‘closed’
ticket[‘resolution’] = ‘fixed’

def _cmdRefs(self, ticket):
pass

if __name__ == “__main__”:
if len(sys.argv) < 5:
print “For usage: %s –help” % (sys.argv[0])
else:
CommitHook()

CUDA EmuDebug problem (cudaError_enum)

If you are willing to debug cuda code u may have 2 options one is nexus which requires 2 GPU Enabled cards for local debugging and the other ugly way EMUDEBUG Configuration but there is a tricky problem. Altough your code works perfect for standart Debug on GPU, when u switch to EMUDEBUG suprise u have Microsoft C++ exception: cudaError_enum So do not forget to change the library cudart.lib to cudartemu.lib.
cudartemu

Cuda hash

At last i can manage to write some code and finished the very first step of a project about cuda and sha-3 candidates.
If you’re interested, please have a look at trac home.
Currently our crew is one guru Gökay Saldamli and insignificant me. But i believe the future is CUDA and this project can be a good base for new hashing algorithms.
Especially for file systems or fast comparison of huge files.

He is going to JAPAN. GOOD TRIP MY FRIEND

Git oraya    gez  dolaşşş   iyice dolaşşş     heryere gir. bak bakalım neler varmış

japan

japan

CUDA and Intellisense

CUDA SDK helps developers to use GPU computing power to c developers. You may find help in SDK about code coloring in Visual Studio. But i am sure many of you have been searching for intellisense for cu and cuh as c files. Here is my solution.

Add c and cuh extensions to NCB Default C/C++ Extensions key under
HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\9.0\Languages\Language Services\C/C++ path

File Manager For TinyMCE

I really hate when a open source project (TinyMCE) relies on a commercial product  (MCFileManager) to work. After some hard work here is a file manager for all. Download here . Requires Microsoft .NET Framework 3.5 (Update Panel used.). Turkish language support is added.
Do not forget to add “filemanager” into plugins line and file_browser_path setting in tinyMCE.init() function.

tinyMCE.init({
// General options
mode: "exact",
...
plugins: "safari...,filemanager",
...
file_browser_path:"http://www.urhost.com/uploadfolder/"
...

Interesting Notes – Part I

  1. About 50% of all defects are introduced during programming, the phase in which actual
    coding takes place. Whereas just 15% of all errors are detected in the initial design stages,
    most errors are found during testing. At the start of unit testing, which is oriented to
    discovering defects in the individual software modules that make up the system, a defect
    density of about 20 defects per 1000 lines of (uncommented) code is typical. This has
    been reduced to about 6 defects per 1000 code lines at the start of system testing, where
    a collection of such modules that constitutes a real product is tested. On launching a new
    software release, the typical accepted software defect density is about one defect per 1000
    lines of code lines.
  2. Errors are typically concentrated in a few software modules – about half of the modules
    are defect free, and about 80% of the defects arise in a small fraction (about 20%) of
    the modules – and often occur when interfacing modules. The repair of errors that are
    detected prior to testing can be done rather economically. The repair cost significantly
    increases from about $ 1000 (per error repair) in unit testing to a maximum of about
    $ 12,500 when the defect is demonstrated during system operation only. It is of vital
    importance to seek techniques that find defects as early as possible in the software design
    process: the costs to repair them are substantially lower, and their influence on the rest
    of the design is less substantial.
  3. The Ariane-5 launch on June 4, 1996; it crashed 36 seconds after the launch
    due to a conversion of a 64-bit floating point into a 16-bit integer value.

In case of u don’t know

There is an old Turkish proverb;

it is not shameful to be unacquainted, alas not to learn is

This code sample returns the distance of a point (x,y) to a line ((x0,y0),(x1,y1))


(((y0 - y1) * x) + ((x1 - x0) * y) + ((x0 * y1) - (x1 * y0)) ) / Math.Sqrt(Math.Pow((x1 - x0),2)+ Math.Pow((y1 - y0),2))

Switch or IndexOf

Which one outperforms other ?

string[] array = new string[] {"a","b","c"};
found = (Array.IndexOf<string>(array, searchedValue) >= 0);

Or

switch (searchedValue)
{
case "a":
case "b":
case "c":
found = true;
break;
default:
found = false;
break;
}

Actually for me it is a matter of design. The first array approach may be suitable for group of strings representing a same subject such as names of employees, model of cars, etc.. but the second one can be a mixed typed. On the other our lead developer (Ertan Tike) approved me execution time of the second one outperforms 7-8 times the first one.