Feature is useful if you are writing your XSD schema files or you have XSD schema files and want to create sample XML files for schema elements. Process is the same for generating sample XML files from DTD files.

How to do it. Simple.

1. Create a project and add, import or somehow see created, generated XSD files in Project Explorer.
2. Select your desired XSD file.
3. Right-click and choose Generate->XML File
4. New XML File wizard will pop-up where you define where generated file should be saved and what should be it’s name. When desired information is input-ed press Next.
5. In Select Root Element window choose root element of your sample XML file. Root element can be any element defined in XSD file you choose to use for generation of the sample XML.
6. Set content options and pay special attention to optional attributes & optional elements. Check those if you would like a complete XML sample.
7. Name-space information is populated with name-spaces defined in chosen XSD file. You can manipulate the existing name-space information by changing prefix, adding additional name-space or create new name-space.
8. Once you are satisfied click Finish.

And presto you have your blank sample XML. Edit it with the information you wish to present and your sample XML is ready. No XMLSpy or any other commercial tools required.

If you are using xmlbeans on Windows to bind your schema to Java types then you are probably using a tool bundled with the distribution called scomp or Schema Compiler. For schema compiler to work you will need to correctly setup computer environment by installing JDK. You can follow through the following check-list to detect if any additional installation steps are required on your machine setup:

• Start->Run->type cmd and type java in the command line. If no error then your setup is correct; otherwise setup JAVA_HOME and add %JAVA_HOME%/bin to your Path environment variable and try again.
• Start->Run->type cmd and type scomp in the command line. If no error then your setup is correct; otherwise setup XMLBEANS_HOME and add %XMLBEANS_HOME%/bin to your Path environment variable and try again.

Then run scomp. Depending on your wishes you will probably wan’t to create a .jar file of the Java types scomp compiles from schema files. I used the following command line:

scomp -d schema -src src -out my_schema_1_0_0.jar ./schema/mySchema.xsd

where mySchema.xsd file was stored in ./schema folder.

If you get my_schema_1_0_0.jar, by some coincidence then kudos to you, but most likely you will end up with something similar to this error:

Time to build schema type system: 1.282 seconds
Time to generate code: 18.687 seconds
java.io.IOException: Cannot run program "C:\your current path\javac": CreateProcess error=2, The system cannot find the file specified
java.io.IOException: CreateProcess error=2, The system cannot find the file specified
java.io.IOException: Cannot run program "C:\your current path\javac": CreateProcess error=2, The system cannot find the file specified
 at java.lang.ProcessBuilder.start(Unknown Source)
 at java.lang.Runtime.exec(Unknown Source)
 at java.lang.Runtime.exec(Unknown Source)
 ... 6 more
BUILD FAILED

Read on to solve this problem.

Yay!!!  There is a problem in your Path environment variable. Let’s try to troubleshoot. Did you install JDK? If you did not then install it. If you did you probably installed it by accepting default installation values. It was installed to C:\Program files\Java\jdk<version>.

The problem is “Program files”. See the space? Java does not like spaces in the command line. As in any other programming language, space represents additional argument to the program. You could try to replace the C:\Program files with classical 8.3 old MS-DOS format, which 1980 users love so much. Execute dir /x in C:\ and replace your “Program files” with PROGRA~2 or PROGRA~1 or whatever Windows thinks “Program files” maps to in your JAVA_HOME and Path environment variables. I am guessing that this will not win me a gold star and you are still reading the next paragraph. And I promise you that if you click one of the Support Us links on the right side you will have three less starving wise men in the world, and you will feel content with your self by clicking on it. But your Path environment variables are now setup correctly.

Now you could search the web and find the answer. Use 2’5 hours of your precious time and crack this. Or you could read documentation for scomp. By being smart and reading documentation for scomp you will discover that scomp can solve this Windows nightmare for you. By using the -compiler parameter in command line you get something like this:

scomp -d schema -src src -out my_schema_1_0_0.jar ./schema/mySchema.xsd -compiler C:\Program Files\Java\jdk1.6.0_03\bin\javac.exe

Problem solved.

Note: If you have huge .xsd schemas then you will have to boost memory external Java compiler can use. Use -xm 512m or -xm 1024m to successfully compile your schema.

In the early years of internet growth I had the opportunity to work as a web designer. As web designer I designed a web page. Simple not too complicated. And it rocked. Literally. Admired by many. By today’s standards web page was LAME. Totally. But it used an interesting JavaScript. As now I was using Linux at the time and I replaced the default mouse cursor with cool animated Linux penguin. The penguin was fabulous. The animation was interesting. The script was flawless. It did not bother me that the script was not working in IE because at that time netscape ruled the web and Microsoft did not bother to make it work on Linux.

To fully appreciate what happened next look at one of the high budget horror movies that the industry is feeding you. Dark times came over web development. World wide web – that was once brewing in the black cauldron; broiled over and development became gruesome nightmare. Wars broke out. Major player corporations prayed on the unsuspected developers and lured them to their cause. There were some casualties; but mainly in the management area and web site development became an art. Most of the wars ended in status quo or with legislation disputes and web developers got standardization. Or did we?

Once you get a task of developing a web page you surely think about which technology you will be using. You weigh between Adobe Flash and Silverlight, client side or server side scripting. But in the end you still have to write an HTML document. Usually you will want to include some kind of client side script. Probably JavaScript so that you are platform independent. For example you will want to do simple background image replacement triggered on HTML elements onMouseOver event. Thinking like this will force you to create a document that is similar to this:

1
2
3
4
5
6
7
8
9

<html>
<head>
<title>JavaScript Test</title>
</head>
<body>
<div id="square" style="margin: 0pt auto; background-color: green; width: 100px; height: 100px;" onmouseover="document.getElementById('square').style.backgroundColor='red';" onmouseout="document.getElementById('square').style.backgroundColor='green';">
</div>
</body>
</html>

Security warning without MOTW in IE6+

Result will look promising in every browser. Except IE. Specially if you are developing for 6+ version of the IE.  Not knowing that Microsoft expertly decided that their web browser MUST improve security of your computer.  And here is where a developer stops with development and starts searching for a solution.

Solution is quite simple if you know where to look for it. The web page running in web browser is run locally and is not hosted on any web server. As a result IE forces web page to run in the security zone of the location the page was saved from. Since the page was created on your local computer this is pretty stupid but for the sake of our computer security let’s go with it. Microsoft also states that this is true as long as that security zone is more restrictive than the Local Machine zone, otherwise Local Machine zone is used. So we opened the file and it got bumped to Local Machine Zone which does not allow executing any script without blocking it. Now I am clapping as mad to the ingenuity of IE developers and on the other hand seeping madly through tons of useless internet garbage until I discovered MOTW. MOTW – is an acronym meaning “Mark of the Web”.

Actually it is an HTML comment which is added to the markup of the page right after <!DOCTYPE/> element. When a user opens the Web page from their local machine, Internet Explorer references this comment to determine the security zone in which it should run the page. For local domain it will look like this:

1

<!-- saved from url=(0014)about:internet -->

By adding this comment to my HTML page JavaScript miraculously started to work. Bravo Microsoft. Here is just another example of the standardization of the web:

1
2
3
4
5
6
7
8
9
10

<!-- saved from url=(0014)about:internet -->
<html>
<head>
<title>JavaScript Test</title>
</head>
<body>
<div id="square" style="margin: 0pt auto; background-color: green; width: 100px; height: 100px;" onmouseover="document.getElementById('square').style.backgroundColor='red';" onmouseout="document.getElementById('square').style.backgroundColor='green';">
</div>
</body>
</html>

Today we will take a look at the abstract factory design pattern. This design pattern continues the series of creational patterns.

In previous article we have talked about factory pattern. We have learned that factory pattern deals with creation of other objects. Now we will extend that knowledge with the abstract factory pattern which provides a way to group together or rather encapsulate a group of individual factories that create objects with common theme.

Normally we would code a client software to create a concrete implementation of the abstract factory and then use generic interfaces to create concrete objects that are tuned to specific theme but, the client does not know about which concrete object will it get from each of the internal factories since it uses generic interfaces of the factory product in question. Details of the implementation of concrete objects are hidden by the internal factories.

Now lets look at an example.

In Java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

public class MusicalFactory {
  private MusicMedia media;
 
  private MusicalFactory() {
  }
 
  public MusicalFactory(MusicMedia _media) {
    media = _media;
  }
 
  public Music createMusic() {
    return media.createMusic();
  }
 
  public interface Music {
    public String getName();
  }
 
  public interface MusicMedia {
    public Music createMusic();
  }
 
  public class Queen implements Music {
    public String getName() {
      return "Queen";
    }
  }
 
  public class TheBeatles implements Music {
    public String getName() {
      return "The Beatles";
    }
  }
 
  public class CompactDisc implements MusicMedia {
    public Music createMusic() {
      return new Queen();
    }
  }
 
  public class LongPlay implements MusicMedia {
    public Music createMusic() {
      return new TheBeatles();
    }
  }
 
  public static MusicMedia createMediaBasedOnEra(int _year) {
    if (_year < 1982)
      return new MusicalFactory().new LongPlay();
    else
      return new MusicalFactory().new CompactDisc();
  }
 
  public static void main(String[] argv) {
    if (argv.length == 1) {
      int year = Integer.parseInt(argv[0]);
 
      MusicalFactory factory = new MusicalFactory(createMediaBasedOnEra(year));
 
      System.out.println("You love: " + factory.createMusic().getName());
    } else {
      System.out.println("Usage: java MusicalFactory ");
    }
  }
}

In PHP:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

interface Music {
  function getName();
}
 
interface MusicMedia {
  function createMusic();
}
 
class Queen implements Music {
  function getName() {
    return "Queen";
  }
}
 
class TheBeatles implements Music {
  function getName() {
    return "The Beatles";
  }
}
 
class CompactDisc implements MusicMedia {
  function createMusic() {
    return new Queen();
  }
}
 
class LongPlay implements MusicMedia {
  function createMusic() {
    return new TheBeatles();
  }
}
 
class MusicalFactory {
  var $media;
  function MusicalFactory($media) {
    $this->$media = $media;
  }
 
  function createMusic() {
    return $media->createMusic();
  }
}
 
function createMediaBasedOnEra($year) {
  if ($year < 1982)
    return new CompactDisc();
  else
    return new LongPlay();
}
 
$musicalFactory = new MusicalFactory(createMediaBasedOnEra(1980));
 
echo "You like: " . $musicalFactory->createMusic()->getName();

In Python:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

class Music:
    def getName(self): raise NotImplementedError
 
class MusicMedia:
    def createMusic(self): raise NotImplementedError
 
class Queen(Music):
    def getName(self): return "Queen"
 
class TheBeetles(Music):
    def getName(self): return "The Beetles"
 
class CompactDisc(MusicMedia):
    def createMusic(self): return Queen()
 
class LongPlay(MusicMedia):
    def createMusic(self): return TheBeetles()
 
class MusicalFactory():
    musicalFactory = 0
    def __init__(self, musicalFactory):
        MusicalFactory.musicalFactory = musicalFactory
 
    def createMusic(self):
        return MusicalFactory.musicalFactory.createMusic()
 
def createMediaBasedOnEra(year):
    if year < 1982:
        return LongPlay()
    else:
        return CompactDisc()
 
if __name__ == '__main__':
    factory = MusicalFactory(createMediaBasedOnEra(1980))
    print "You like: %s" % factory.createMusic().getName()

In C++:
Header file:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#include 
 
class Music
{
public:
	virtual std::string getName() = 0;
};
 
class MusicMedia {
public:
	virtual Music* createMusic() = 0;
};
 
class Queen : public Music
 {
public:
	virtual std::string getName();
};
 
class TheBeetles : public Music {
public:
	std::string getName();
};
 
class CompactDisc : public MusicMedia {
public:
	Music* createMusic();
};
 
class LongPlay : public MusicMedia {
public:
	Music* createMusic();
};
 
class MusicFactory {
public:
	MusicFactory(MusicMedia* factory);
 
	Music* createMusic();
private:
	MusicMedia* m_factory;
};

And source file:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#include "abstractfactory.hpp"
 
std::string Queen::getName() {
	return std::string("Queen");
}
std::string TheBeetles::getName() {
	return std::string("The Beatles");
}
 
Music* CompactDisc::createMusic() {
	return new Queen();
}
 
Music* LongPlay::createMusic() {
	return new TheBeetles();
}
 
MusicFactory::MusicFactory(MusicMedia* factory) {
	m_factory = factory;
}
 
Music* MusicFactory::createMusic() {
	return (m_factory->createMusic());
}
 
MusicMedia* createMediaBasedOnEra(int _year) {
    if (_year < 1982)
		return new LongPlay();
    else
		return new CompactDisc();
}
 
int main(int argc, char *argv[]) {
	MusicFactory factory = MusicFactory(createMediaBasedOnEra(1980));
	std::cout << "You like: " << factory.createMusic()->getName().c_str();
}

The main idea of the example is that createMediaBasedOnEra() method creates a MusicMedia. MusicMedia is an abstract factory that can produce Music based on that era. Now the example is intended to show how we can hide implementation details.

As already shown factory is the location where objects are constructed. Pattern’s intent is to isolate the creation of objects from their usage. New derived types can be introduced in the code without significant code change to the base class. Downside of the implementation of this patten is additional complexity to the code. It can also mean additional initial effort for developers. You should weigh cost – benefit before implementation.

The Factory method pattern deals with creating objects without specifying the exact class of the object that will be created. Pattern defines separate methods for creating objects, whose subclasses can be overridden to specify the derived type of the product that factory will create. It is basically any method whose purpose is creation of the objects.

Factory method pattern is used to encapsulate the creation of objects.  When this process is complex or is not simple to understand, than it is prudent to use factory method pattern in your design. Pattern is useful if you are writing a toolkit of framework code where you want to encapsulate the creation of toolkit or framework specific objects. You will definitely benefit from factory methods when you have parallel class hierarchy between objects, because one type of objects will have to be able to create objects from other type.  There is where encapsulated factory method becomes handy. You will come in contact with this pattern with the applications that are unit tested. More precisely in applications that use test driven development as a base for their development cycle.

Well I think it is time for some examples. As the name of our post tells us we will create a factory method which will produce fungi. If we look at the UML our Product will be replaced with Fungus. Our ConcreteCreator and Creator will be replaced with FungusFactory. Method called factoryMethod will be replaced with create method. Now let’s create some fungus in Java.

public class FungusFactory {
	private static FungusFactory instance;
	public enum FungusFamily {
		Microsporidia,
		Chytridiomycota,
		Zoopagomycotina
	}
	public interface Fungus {
		public String getFamily();
	}
	public class MicrospordiaFungus implements Fungus {
		private String family = "Microsporidia";
		public String getFamily() { return family; }
	}
	public class ChytridiomycotaFungus implements Fungus {
		private String family = "Chytridiomycota";
		public String getFamily() { return family; }
	}
	public class ZoopagomycotinaFungus implements Fungus {
		private String family = "Zoopagomycotina";
		public String getFamily() { return family; }
	}
	public static synchronized Fungus create(FungusFamily _family) {
		if (instance == null)
			instance = new FungusFactory();
		switch (_family) {
			case Microsporidia:
				return instance.new MicrospordiaFungus();
			case Chytridiomycota:
				return instance.new ChytridiomycotaFungus();
			case Zoopagomycotina:
				return instance.new ZoopagomycotinaFungus();
		}
		throw new IllegalArgumentException("This factory can't " +
                             "make fungus of unknown family [" + _family + "]") ;
	}
	public static void main(String [] argv) {
		Fungus microsporidiaFungus =
                    FungusFactory.create(FungusFactory.FungusFamily.Microsporidia);
		System.out.println(microsporidiaFungus.getFamily());
	}
}

In PHP:

class FungusFactory {
  static function create($family) { // As of PHP 5.3.0
    switch ($family) {
     case 'Microsporidia': return new MicrosporidiaFungus();
     case 'Chytridiomycota': return new ChytridiomycotaFungus();
     case 'Zoopagomycotina': return new ZoopagomycotinaFungus();
  }
}
interface Fungus {
  function getFamily();
}
class MicrosporidiaFungus implements Fungus {
  function getFamily() { return 'Microsporidia'; }
}
class ChytridiomycotaFungus implements Fungus {
  function getFamily() { return 'Chytridiomycota'; }
}
class ZoopagomycotinaFungus implements Fungus {
  function getFamily() { return 'Zoopagomycotina'; }
}
function test() {
  echo FungusFactory::create('Microsporidia')->getFamily();
}

In python:

class FungusFactory:
    def create( self, family ):
        if family == "Microsporidia":
            return MicrospordiaFungus()
        elif family == "Chytridiomycota":
            return ChytridiomycotaFungus()
        elif family == "Zoopagomycotina":
            return ZoopagomycotinaFungus()
        else:
            return Fungus()
   create = staticmethod(create)
class Fungus:
    def getFamily( self ): raise NotImplementedError
class MicrospordiaFungus( Fungus ):
    def getFamily( self ): return "Microsporidia"
class ChytridiomycotaFungus ( Fungus ):
    def getFamily( self ): return "Chytridiomycota"
class ZoopagomycotinaFungus ( Fungus ):
    def getFamily( self ): return "Zoopagomycotina"
if __name__ == "__main__":
    print FungusFactory.create("Microsporidia").getFamily()

In C++:

Header:

class Fungus {
public:
  virtual std::string getFamily() = 0;
};
class MicrosporidiaFungus: public Fungus {
public:
  std::string getFamily();
};
class ChytridiomycotaFungus: public Fungus {
public:
  std::string getFamily();
};
class ZoopagomycotinaFungus: public Fungus {
public:
  std::string getFamily();
};
class FungusFactory {
public:
  static const int MICROSPORIDIA = 1;
  static const int CHYTRIDIOMYCOTA = 2;
  static const int ZOOPAGOMYCOTINA = 3;
  static Fungus* create(int type);
};

Source:

#include "factory.hpp"
Fungus* FungusFactory::create(int family)
{
  switch (family)
  {
    case FungusFactory::MICROSPORIDIA:
      return new MicrosporidiaFungus();
      break;
    case FungusFactory::CHYTRIDIOMYCOTA:
      return new ChytridiomycotaFungus();
      break;
    case FungusFactory::ZOOPAGOMYCOTINA:
      return new ZoopagomycotinaFungus();
      break;
  }
  throw new std::string("This factory can't make fungus of unknown family");
}
std::string MicrosporidiaFungus::getFamily()
{
  return std::string("Microsporidia");
}
std::string ChytridiomycotaFungus::getFamily()
{
  return std::string("Chytridiomycota");
}
std::string ZoopagomycotinaFungus::getFamily()
{
  return std::string("Zoopagomycotina");
}
int main(int argc, char *argv[])
{
  std::cout << FungusFactory::create(FungusFactory::MICROSPORIDIA)->getFamily() << std::endl;
}

Now as with singleton there are some drawbacks from using the factory method pattern. If you are re-factoring existing code you should watch out for your client classes which you will break in process. All instances of object creation that you will replace by factory methods must be replaced with factory method calls. Now if you have an application that creates a lot of objects in the code you have your work cut out for you. The factory method relays on private constructor, hence it can not be extended. If we by any chance make the constructor protected or even good forbid public and somehow are able to extend the existing factory, the extended factory must re-implement all the factory methods defined in base factory.

This is all the juice we have for today. Next week we will look at another factory pattern. That one will have more abstraction in it.

Now I am not the best programmer in the world and also not the worst. Maybe I was lucky to be born in the era in which pattern design sprouted and started to grow. Also I know that most of you dear readers don’t need to reread this simple stuff, but if you are unsure of something … go ahead and take a peek. We will not tell ;)

This should be a first of design pattern series. So come back and check out the one of which you are unsure of.

The illusive Singleton

It is a design pattern that is used to control and restrict instantiation of a class to one and only one object. Simple, ehh? Why for God’s sake would you want to do that? Since this pattern is a creational pattern we use it when we need exactly one object to coordinate some events or actions across the whole system.

On the right we have a diagram in UML notation which shows how our singleton class should look like.

We can use this design pattern for instantiation of other design pattens, to describe objects that describe states of the system, use them as a global reference to the instances of specific classes, because they don’t pollute the global namespace with unnecessary variables and they allow lazy allocation and initialization.

When implementing singleton programmers must bare in mind that we need only one instance of the class and that instance requires global access principle. It is implemented by creating a class with a method that creates a new instance of the singleton class if one does not exist. If the instance already exists a reference to that object is returned. Implementation needs to make sure that no other classes can instantiate the class so usually constructor is hidden. When programming in multi-threaded applications and two threads access the creation method at the same time and the singleton instance does not yet exist, they should both check for an instance and only one should create the new instance. This is usually solved by using mutual exclusion on the class that indicated that the object is being instantiated.

For this example I will use Java

public class Singleton
{
   private static Singleton singleton;
   private Singleton() { }
   public static synchronized Singleton getInstance()
   {
     if (singleton == null)
     {
       singleton = new Singleton();
     }
     return singleton;
    }
}

And there you have it … The Java Singleton. Java not your thing, how about PHP?

class Singleton
{
  protected static $instance;
  private function __construct() { }
  private function __clone() { }
  public static function getInstance()
  {
    if (null === self::$_instance) {
      self::$_instance = new self();
    }
    return self::$_instance;
  }
}

Still not satisfied ? How about python ?

class Singleton(object):
    def __new__(type):
        if not '_the_instance' in type.__dict__:
            type._the_instance = object.__new__(type)
        return type._the_instance

Maybe C++ ? The header file.

using namespace std;
class Singleton
{
public:
  static Singleton& GetInstance();
  ~Singleton();
private:
  Singleton();
  static Singleton * s_instance;
}

The source file.

Singleton * Singleton::s_instance = 0;
Singleton::Singleton() { }
Singleton::~Singleton()
{
  if (s_instance != 0)
  {
    delete s_instance;
  }
}
Singleton& Singleton::GetInstance()
{
  if (s_instance == 0)
  {
    s_instance = new Singleton();
  }
  return s_instance;
}

An that is all I can tell you about singing with Singletons. Hmm … wait not quite.

It should be noted that the singleton pattern, although simple to understand, does not get much love from the “gurus”. First of all it will make all the code depend on that class, meaning if a singleton class is changed all of the code that uses that class will be broken and has to be mended. Also since it uses private and static methods this pattern is sometimes seen as an anti pattern. Code can be difficult to unit test since the pattern introduces global state and unit tests need to be aware of that.

Next we will tackle the Factory patterns and see what we can manufacture with them. Till next time.