public class Book
		{
			public String title;
			public String author;
			public int published;

			@Override
			public String toString()
			{
				return title + " by " + author + ", published in " + published ;
			}
		}

		public class Library
		{
			ArrayList<Book> books = new ArrayList<Book>();
		}

		private static class BookBuilder extends AbstractObjectBuilder<Book>
		{

			@Override
			public Book get(ElementDescriptor<Book> descriptor, Book recycle, ParserContext context)
			{
				if (recycle != null)
				{
					// recycle the book
					recycle.author = null;
					recycle.title = null;
					recycle.released = -1;
					return recycle;
				}
				// return a new book
				return new Book();
			}


			@Override
			public <V> Book update(ElementDescriptor<Book> descriptor, Book object, ElementDescriptor<V> childType,
					V child, ParserContext context)
			{
				if (childType == TITLE)
				{
					object.title = (String) child;
				}
				else if (childType == AUTHOR)
				{
					object.author = (String) child;
				}
				else if (childType == PUBLISHED)
				{
					object.published = (Integer) child;
				}
				return object;
			}


			@Override
			public void writeChildren(ElementDescriptor<Book> descriptor, Book book, IXmlChildWriter childWriter,
					SerializerContext context) throws SerializerException, IOException
			{
				childWriter.writeChild(TITLE, book.title);
				childWriter.writeChild(AUTHOR book.author;
				childWriter.writeChild(PUBLISHED, book.published);
			}
		}

		private static class LibraryBuilder extends AbstractObjectBuilder<Library>
		{

			@Override
			public Book get(ElementDescriptor<Library> descriptor, Library recycle, ParserContext context)
			{
				if (recycle != null)
				{
					recycle.books.clear();
					return recycle;
				}
				// return a new library
				return new Library();
			}


			@Override
			public <V> Book update(ElementDescriptor<Library> descriptor, Library object, ElementDescriptor<V> childType,
					V child, ParserContext context)
			{
				if (childType == BOOK)
				{
					object.books.add((Book) child);
				}
				return object;
			}


			@Override
			public void writeChildren(ElementDescriptor<Library> descriptor, Library library, IXmlChildWriter childWriter,
					SerializerContext context) throws SerializerException, IOException
			{
				for (Book book:library.books)
				{
					childWriter.writeChild(BOOK, book);
				}
			}
		}

		// author is just a String
		private final static ElementDescriptor<String> AUTHOR =
			ElementDescriptor.register(QualifiedName.get("author"), StringObjectBuilder.INSTANCE);

		// title is just a String as well
		private final static ElementDescriptor<String> TITLE =
			ElementDescriptor.register(QualifiedName.get("title"), StringObjectBuilder.INSTANCE);

		// published is an integer
		private final static ElementDescriptor<Integer> PUBLISHED =
			ElementDescriptor.register(QualifiedName.get("published"), IntegerObjectBuilder.INSTANCE);

		// book is built by a BookBuilder
		private final static ElementDescriptor<Book> BOOK =
			ElementDescriptor.register(QualifiedName.get("book"), new BookBuilder());

		// use the builder above to build & serialize libraries
		private final static ElementDescriptor<Library> LIBRARY =
			ElementDescriptor.register(QualifiedName.get("library"), new LibraryBuilder());

		// get an XmlPullParser
		XmlPullParserFactory pullParserFactory = XmlPullParserFactory.newInstance();
		XmlPullParser parser = pullParserFactory.newPullParser();
		parser.setInput(new StringReader(inputXml) /* pass the reader that reads the xml stream */);

		// get an XmlObjectPull instance for this parser
		XmlObjectPull objectPull = new XmlObjectPull(parser);

		// the path to pull from, i.e. only elements in <library>
		XmlPath libraryPath = new XmlPath(LIBRARY);

		Book book = null;
		while (objectPull.moveToNext(BOOK, libraryPath))
		{
			book = op.pull(BOOK /* pull elements that are Books */,
				book /* recycle the previous book */,
				libraryPath /* pull from this path */);

			// do something with book
		}

		// initialize the serializer for writing to an OutoutStream
		XmlObjectSerializer os = new XmlObjectSerializer(outputstream, "UTF-8", null /* use default context */);

		// serialize a library
		os.serialize(LIBRARY, library);
		
		// done
		out.close();

		private static class Book
		{
			@Element(name = "title")
			public String title;

			@Element(name = "author")
			public String author;

			@Element(name = "published")
			public int published;


			@Override
			public String toString()
			{
				return title + " by " + author + ", published in " + published ;
			}
		}

		// book is built by Reflection 
		private final static ElementDescriptor<Book> BOOK =
			ElementDescriptor.register(QualifiedName.get("book"), new ReflectionObjectBuilder<Book>(Book.class));