EntryLike

abstract def copy(elem: Elem): T

abstract def self: T

abstract def wrapped: Elem

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def \[B](selector: Selector[B]): IndexedSeq[B]

def addAuthor(author: Person): T

def addCategory(category: Category): T

def addChild(node: Node): T

def addChild(w: ElementWrapper): T

def addChild(ns: NamespaceBinding, name: String, node: Node): T

def addChild(ns: NamespaceBinding, name: String, text: String): T

def addChild(name: String, text: String): T

def addChild(text: String): T

def addChildren(children: Group[Node]): T

def addChildren(children: Seq[ElementWrapper]): T

def addContributor(contrib: Person): T

def addLink(link: Link): T

def addLinks(links: IndexedSeq[Link]): T

def addNamespace(prefixNS: (String, String)): T

def addNamespace(prefix: Option[String], namespace: String): T

def addNamespaces(namespaces: Map[String, String]): T

def apply[A >: T, B](ext: AtomExtension[A, B], value: B): T

final def asInstanceOf[T0]: T0

def attr(name: QName): Option[String]

def authorByName(name: String): Option[Person]

def authors: IndexedSeq[Person]

def categories: IndexedSeq[Category]

def categoriesByScheme(scheme: String): IndexedSeq[Category]

def categoryBySchemeAndTerm(scheme: String, term: String): Option[Category]

def clone(): AnyRef

def content: Option[Content]

def contributorByName(name: String): Option[Person]

def contributors: IndexedSeq[Person]

def element(name: String): Zipper[Elem]

def elementText(name: String): IndexedSeq[String]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def extract[A >: T, B](ext: AtomExtension[A, B]): B

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def id: URI

final def isInstanceOf[T0]: Boolean

def linkByRel(rel: String): Option[Link]

def links: IndexedSeq[Link]

def linksByType(mt: MediaType): IndexedSeq[Link]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def published: Option[DateTime]

def replaceChildren(selector: Selector[Elem], children: Group[Node]): T

def replaceChildren(selector: Selector[Elem], children: IndexedSeq[ElementWrapper]): T

def rights: Option[TextConstruct]

def summary: Option[Content]

final def synchronized[T0](arg0: ⇒ T0): T0

def title: TextConstruct

def toString(): String

def updated: DateTime

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withAttribute(name: QName, value: Any): T

def withAttribute(name: String, value: Any): T

def withChildren(children: Group[Node]): T

def withChildren(children: Seq[ElementWrapper]): T

def withContent(content: Content): T

def withId(id: URI): T

def withPublished(published: DateTime): T

def withRights(rights: TextConstruct): T

def withSummary(summary: Content): T

def withTitle(title: TextConstruct): T

def withUpdated(updated: DateTime): T

def writeTo(file: File)(implicit charset: Charset): Unit

def writeTo(stream: OutputStream)(implicit charset: Charset): Unit

def writeTo(writer: Writer)(implicit charset: Charset): Unit

Serializes the ElementWrapper to the given writer.