Treebuilder1

This is the example code for my blog entry JCR with Scala: Adding Nodes in ASCII Art.

package com.day.scalademo;

import org.apache.jackrabbit.core.TransientRepository
import javax.jcr.{Node, Property, SimpleCredentials}

object Treebuilder1 {
    import Extensions._

    def main(args: Array[String]) {
        val repository = new TransientRepository
        val session = repository.login(new SimpleCredentials("username", "password".toCharArray));

        try {
            val node = session.getRootNode ¦- "test"
            addSubtree(node)
            dump(node)
        }
        finally {
            session.logout
        }
    }

    def addSubtree(n: Node) {
        n ¦- "1" -+ { n: Node =>
                n ¦- "i"
                n ¦- "ii"
                n ¦- "iii"
                n ¦- "iv"
                n ¦- "v"
        }
        n ¦- "2"
        n ¦- "3" -+ { n: Node =>
                n ¦- "i"
                n ¦- "ii" -+ { n: Node =>
                         n ¦- "a"
                         n ¦- "b"
                         n ¦- "c"
                }
                n ¦- "iii"
                n ¦- "iv"
                n ¦- "v"
        }
        n ¦- "4"
        n ¦- "5"
        n ¦- ("6", "nt:file")
    }

    def dump(node: Node) {
        println(node.getPath)

        for (property <- node.properties) {
            if (property.getDefinition.isMultiple)
                for(value <- property.getValues)
                    println(property.getPath + " = " + value)
            else
                println(property.getPath + " = " + property.getString)
        }

        for (child <- node.childNodes)
            dump(child)
    }

}

object Extensions {
    implicit def extendNode(node: Node) = new NodeExtender(node)

    protected class NodeExtender(node: Node) {

        def childNodes = new Iterator[Node] {
            val it = node.getNodes
            def hasNext = it.hasNext
            def next = it.nextNode
        }

        def properties = new Iterator[Property] {
            val it = node.getProperties
            def hasNext = it.hasNext
            def next = it.nextProperty
        }

        def -+[T](f: Node => T) = f(node)

        def ¦-(relPath: String) = node.addNode(relPath)
        def ¦-(relPath: String, tyqe: String) = node.addNode(relPath, tyqe)
    }

}