play.db.anorm.Convention

# Magic

#### case class Magic [T] (tableName: Option[String], conventions: PartialFunction[AnalyserInfo, String], m: ClassManifest[T]) extends Parser[T] with M[T] with Product

go to: companion
linear super types: Product, Equals, M[T], MParser[T], ParserWithId[T], Parser[T], (Input) ⇒ ParseResult[T], AnyRef, Any
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. Hide All
2. Show all

1. Magic
2. Product
3. Equals
4. M
5. MParser
6. ParserWithId
7. Parser
8. Function1
9. AnyRef
10. Any

Visibility

1. Public
2. All

Impl.

1. Concrete
2. Abstract

### Instance constructors

1. #### new Magic (tableName: Option[String] =, conventions: PartialFunction[AnalyserInfo, String] =)(implicit m: ClassManifest[T])

### Value Members

1. #### def != (arg0: AnyRef) : Boolean

   attributes: final
   definition classes: AnyRef

2. #### def != (arg0: Any) : Boolean

   `o != arg0` is the same as `!(o == (arg0))`.

   `o != arg0` is the same as `!(o == (arg0))`.

   arg0

     the object to compare against this object for dis-equality.

   returns

     `false` if the receiver object is equivalent to the argument; `true` otherwise.

   attributes: final
   definition classes: Any

3. #### def ## () : Int

   attributes: final
   definition classes: AnyRef → Any

4. #### def $asInstanceOf [T0] () : T0

   attributes: final
   definition classes: AnyRef

5. #### def $isInstanceOf [T0] () : Boolean

   attributes: final
   definition classes: AnyRef

6. #### def * [U >: T] (sep: ⇒ Parser[(U, U) ⇒ U]) : Parser[U]

   Returns a parser that repeatedly parses what this parser parses, interleaved with the `sep' parser. The` sep' parser specifies how the results parsed by this parser should be combined.

   Returns a parser that repeatedly parses what this parser parses, interleaved with the `sep' parser. The` sep' parser specifies how the results parsed by this parser should be combined.

   returns

     chainl1(this, sep)

   definition classes: Parser

7. #### def * : Parser[List[T]]

   Returns a parser that repeatedly parses what this parser parses

   Returns a parser that repeatedly parses what this parser parses

   returns

     rep(this)

   definition classes: Parser

8. #### def + : Parser[List[T]]

   Returns a parser that repeatedly (at least once) parses what this parser parses.

   Returns a parser that repeatedly (at least once) parses what this parser parses.

   returns

     rep1(this)

   definition classes: Parser

9. #### def <~ [U] (q: ⇒ Parser[U]) : Parser[T]

   A parser combinator for sequential composition which keeps only the left result

   A parser combinator for sequential composition which keeps only the left result

   `p &lt;~ q' succeeds if` p' succeeds and `q' succeeds on the input left over by` p'.

   Note: &lt;~ has lower operator precedence than ~ or ~>.

   q

     a parser that will be executed after `p' (this parser) succeeds -- evaluated at most once, and only when necessary`

   returns

     a `Parser' that -- on success -- returns the result of` p'.

   definition classes: Parser

10. #### def == (arg0: AnyRef) : Boolean

    `o == arg0` is the same as `if (o eq null) arg0 eq null else o.equals(arg0)`.

    `o == arg0` is the same as `if (o eq null) arg0 eq null else o.equals(arg0)`.

    arg0

      the object to compare against this object for equality.

    returns

      `true` if the receiver object is equivalent to the argument; `false` otherwise.

    attributes: final
    definition classes: AnyRef

11. #### def == (arg0: Any) : Boolean

    `o == arg0` is the same as `o.equals(arg0)`.

    `o == arg0` is the same as `o.equals(arg0)`.

    arg0

      the object to compare against this object for equality.

    returns

      `true` if the receiver object is equivalent to the argument; `false` otherwise.

    attributes: final
    definition classes: Any

12. #### def >> [U] (fq: (T) ⇒ Parser[U]) : Parser[U]

    Returns into(fq)

    Returns into(fq)

    definition classes: Parser

13. #### def ? : Parser[Option[T]]

    Returns a parser that optionally parses what this parser parses.

    Returns a parser that optionally parses what this parser parses.

    returns

      opt(this)

    definition classes: Parser

14. #### def ^? [U] (f: PartialFunction[T, U]) : Parser[U]

    A parser combinator for partial function application

    A parser combinator for partial function application

    `p ^? f' succeeds if` p' succeeds AND `f' is defined at the result of` p'; in that case, it returns `f' applied to the result of` p'.

    f

      a partial function that will be applied to this parser's result (see `mapPartial' in` ParseResult').

    returns

      a parser that succeeds if the current parser succeeds and `f' is applicable to the result. If so, the result will be transformed by` f'.

    definition classes: Parser

15. #### def ^? [U] (f: PartialFunction[T, U], error: (T) ⇒ String) : Parser[U]

    A parser combinator for partial function application

    A parser combinator for partial function application

    `p ^? (f, error)' succeeds if` p' succeeds AND `f' is defined at the result of` p'; in that case, it returns `f' applied to the result of` p'. If `f' is not applicable, error(the result of` p') should explain why.

    f

      a partial function that will be applied to this parser's result (see `mapPartial' in` ParseResult').

    error

      a function that takes the same argument as `f' and produces an error message to explain why` f' wasn't applicable

    returns

      a parser that succeeds if the current parser succeeds and `f' is applicable to the result. If so, the result will be transformed by` f'.

    definition classes: Parser

16. #### def ^^ [U] (f: (T) ⇒ U) : Parser[U]

    A parser combinator for function application

    A parser combinator for function application

    `p ^^ f' succeeds if` p' succeeds; it returns `f' applied to the result of` p'.

    f

      a function that will be applied to this parser's result (see `map' in` ParseResult').

    returns

      a parser that has the same behaviour as the current parser, but whose result is transformed by `f'.`

    definition classes: Parser

17. #### def ^^^ [U] (v: ⇒ U) : Parser[U]

    A parser combinator that changes a successful result into the specified value.

    A parser combinator that changes a successful result into the specified value.

    `p ^^^ v' succeeds if` p' succeeds; discards its result, and returns `v` instead.

    v

      The new result for the parser, evaluated at most once (if `p` succeeds), not evaluated at all if `p` fails.

    returns

      a parser that has the same behaviour as the current parser, but whose successful result is `v`

    definition classes: Parser

18. #### val analyser : Analyse[T]

    definition classes: MParser

19. #### def andThen [A] (g: (ParseResult[T]) ⇒ A) : (Input) ⇒ A

    definition classes: Function1

20. #### def append [U >: T] (p0: ⇒ Parser[U]) : Parser[U]

    definition classes: Parser

21. #### def apply (input: Input) : ParseResult[T]

    An unspecified method that defines the behaviour of this parser.

    An unspecified method that defines the behaviour of this parser.

    definition classes: MParser → ParserWithId → Parser → Function1

22. #### def asInstanceOf [T0] : T0

    This method is used to cast the receiver object to be of type `T0`.

    This method is used to cast the receiver object to be of type `T0`.

    Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression`1.asInstanceOf[String]` will throw a `ClassCastException` at runtime, while the expression`List(1).asInstanceOf[List[String]]` will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested typed.

    returns

      the receiver object.

    attributes: final
    definition classes: Any

23. #### def canEqual (arg0: Any) : Boolean

    definition classes: Magic → Equals

24. #### def clone () : AnyRef

    This method creates and returns a copy of the receiver object.

    This method creates and returns a copy of the receiver object.

    The default implementation of the `clone` method is platform dependent.

    returns

      a copy of the receiver object.

    attributes: protected
    definition classes: AnyRef

25. #### def compose [A] (g: (A) ⇒ Input) : (A) ⇒ ParseResult[T]

    definition classes: Function1

26. #### val conventions : PartialFunction[AnalyserInfo, String]

    definition classes: Magic → M → MParser

27. #### def count (stmt: String ="") : SimpleSql[Long]

    definition classes: M

28. #### def create (v: T) : MayErr[IntegrityConstraintViolation, T]

    definition classes: M

29. #### def delete (stmt: String) : SqlQuery

    definition classes: M

30. #### def eq (arg0: AnyRef) : Boolean

    This method is used to test whether the argument (`arg0`) is a reference to the receiver object (`this`).

    This method is used to test whether the argument (`arg0`) is a reference to the receiver object (`this`).

    The `eq` method implements an [http://en.wikipedia.org/wiki/Equivalence_relation equivalence relation] on non-null instances of `AnyRef`: * It is reflexive: for any non-null instance `x` of type `AnyRef`, `x.eq(x)` returns `true`. * It is symmetric: for any non-null instances `x` and `y` of type `AnyRef`, `x.eq(y)` returns `true` if and only if `y.eq(x)` returns `true`. * It is transitive: for any non-null instances `x`, `y`, and `z` of type `AnyRef` if `x.eq(y)` returns `true` and `y.eq(z)` returns `true`, then `x.eq(z)` returns `true`.

    Additionally, the `eq` method has three other properties. * It is consistent: for any non-null instances `x` and `y` of type `AnyRef`, multiple invocations of `x.eq(y)` consistently returns `true` or consistently returns `false`. * For any non-null instance `x` of type `AnyRef`, `x.eq(null)` and `null.eq(x)` returns `false`. * `null.eq(null)` returns `true`.

    When overriding the `equals` or `hashCode` methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (`o1 eq o2`), they should be equal to each other (`o1 == o2`) and they should hash to the same value (`o1.hashCode == o2.hashCode`).

    arg0

      the object to compare against this object for reference equality.

    returns

      `true` if the argument is a reference to the receiver object; `false` otherwise.

    attributes: final
    definition classes: AnyRef

31. #### def equals (arg0: Any) : Boolean

    This method is used to compare the receiver object (`this`) with the argument object (`arg0`) for equivalence.

    This method is used to compare the receiver object (`this`) with the argument object (`arg0`) for equivalence.

    The default implementations of this method is an [http://en.wikipedia.org/wiki/Equivalence_relation equivalence relation]: * It is reflexive: for any instance `x` of type `Any`, `x.equals(x)` should return `true`. * It is symmetric: for any instances `x` and `y` of type `Any`, `x.equals(y)` should return `true` if and only if `y.equals(x)` returns `true`. * It is transitive: for any instances `x`, `y`, and `z` of type `AnyRef` if `x.equals(y)` returns `true` and `y.equals(z)` returns `true`, then `x.equals(z)` should return `true`.

    If you override this method, you should verify that your implementation remains an equivalence relation. Additionally, when overriding this method it is often necessary to override `hashCode` to ensure that objects that are "equal" (`o1.equals(o2)` returns `true`) hash to the same scala.Int (`o1.hashCode.equals(o2.hashCode)`).

    arg0

      the object to compare against this object for equality.

    returns

      `true` if the receiver object is equivalent to the argument; `false` otherwise.

    definition classes: Magic → Equals → AnyRef → Any

32. #### def finalize () : Unit

    This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object.

    This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object.

    The details of when and if the `finalize` method are invoked, as well as the interaction between `finalize`and non-local returns and exceptions, are all platform dependent.

    attributes: protected
    definition classes: AnyRef

33. #### def find (stmt: String ="") : SimpleSql[T]

    definition classes: M

34. #### def flatMap [U] (f: (T) ⇒ Parser[U]) : Parser[U]

    definition classes: Parser

35. #### def getClass () : java.lang.Class[_]

    Returns a representation that corresponds to the dynamic class of the receiver object.

    Returns a representation that corresponds to the dynamic class of the receiver object.

    The nature of the representation is platform dependent.

    returns

      a representation that corresponds to the dynamic class of the receiver object.

    attributes: final
    definition classes: AnyRef

36. #### def getExtractor [C] (m: Manifest[C]) : Option[ColumnTo[C]]

    definition classes: MParser

37. #### def hashCode () : Int

    Returns a hash code value for the object.

    Returns a hash code value for the object.

    The default hashing algorithm is platform dependent.

    Note that it is allowed for two objects to have identical hash codes (`o1.hashCode.equals(o2.hashCode)`) yet not be equal (`o1.equals(o2)` returns `false`). A degenerate implementation could always return `0`. However, it is required that if two objects are equal (`o1.equals(o2)` returns `true`) that they have identical hash codes (`o1.hashCode.equals(o2.hashCode)`). Therefore, when overriding this method, be sure to verify that the behavior is consistent with the `equals` method.

    returns

      the hash code value for the object.

    definition classes: Magic → AnyRef → Any

38. #### val idParser : play.db.anorm.SqlParser.Parser[_]

    definition classes: M

39. #### def insert (v: T) : MayErr[IntegrityConstraintViolation, Boolean]

    definition classes: M

40. #### def into [U] (fq: (T) ⇒ Parser[U]) : Parser[U]

    A parser combinator that parameterizes a subsequent parser with the result of this one

    A parser combinator that parameterizes a subsequent parser with the result of this one

    Use this combinator when a parser depends on the result of a previous parser. `p' should be a function that takes the result from the first parser and returns the second parser.` p into fq' (with `fq' typically` {x => q}') first applies `p', and then, if` p' successfully returned result `r', applies` fq(r)' to the rest of the input.

    From: G. Hutton. Higher-order functions for parsing. J. Funct. Program., 2(3):323--343, 1992.

    fq

      a function that, given the result from this parser, returns the second parser to be applied

    returns

      a parser that succeeds if this parser succeeds (with result `x') and if then` fq(x)' succeeds

    definition classes: Parser

41. #### def isInstanceOf [T0] : Boolean

    This method is used to test whether the dynamic type of the receiver object is `T0`.

    This method is used to test whether the dynamic type of the receiver object is `T0`.

    Note that the test result of the test is modulo Scala's erasure semantics. Therefore the expression`1.isInstanceOf[String]` will return `false`, while the expression `List(1).isInstanceOf[List[String]]` will return `true`. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested typed.

    returns

      `true` if the receiver object is an instance of erasure of type `T0`; `false` otherwise.

    attributes: final
    definition classes: Any

42. #### implicit val m : ClassManifest[T]

    attributes: implicit
    definition classes: Magic → MParser

43. #### def map [U] (f: (T) ⇒ U) : Parser[U]

    definition classes: Parser

44. #### val msql : MSql[T]

    definition classes: M

45. #### def named (n: String) : Magic.this.type

    definition classes: Parser

46. #### def ne (arg0: AnyRef) : Boolean

    `o.ne(arg0)` is the same as `!(o.eq(arg0))`.

    `o.ne(arg0)` is the same as `!(o.eq(arg0))`.

    arg0

      the object to compare against this object for reference dis-equality.

    returns

      `false` if the argument is not a reference to the receiver object; `true` otherwise.

    attributes: final
    definition classes: AnyRef

47. #### def notify () : Unit

    Wakes up a single thread that is waiting on the receiver object's monitor.

    Wakes up a single thread that is waiting on the receiver object's monitor.

    attributes: final
    definition classes: AnyRef

48. #### def notifyAll () : Unit

    Wakes up all threads that are waiting on the receiver object's monitor.

    Wakes up all threads that are waiting on the receiver object's monitor.

    attributes: final
    definition classes: AnyRef

49. #### def on (differentTableName: String) : ParserWithId[T]

    definition classes: MParser

50. #### def productArity : Int

    definition classes: Magic → Product

51. #### def productElement (arg0: Int) : Any

    definition classes: Magic → Product

52. #### def productElements : Iterator[Any]

    definition classes: Product
    deprecated:

    1. use productIterator instead

53. #### def productIterator : Iterator[Any]

    definition classes: Product

54. #### def productPrefix : String

    definition classes: Magic → Product

55. #### def span [B] (p: Parser[B]) : Parser[B]

    definition classes: ParserWithId

56. #### def spanM [B] (b: Parser[B]) : Parser[List[B]]

    definition classes: ParserWithId

57. #### def synchronized [T0] (arg0: T0) : T0

    attributes: final
    definition classes: AnyRef

58. #### val tableName : Option[String]

    definition classes: Magic → MParser

59. #### def toString () : String

    Returns a string representation of the object.

    Returns a string representation of the object.

    The default representation is platform dependent.

    returns

      a string representation of the object.

    definition classes: Parser → Function1 → AnyRef → Any

60. #### val uniqueId : (Row) ⇒ MayErr[SqlRequestError, Any]

    definition classes: MParser → ParserWithId

61. #### def update (v: T) : Unit

    definition classes: M

62. #### def using (tableName: Symbol) : Magic[T]

63. #### def wait () : Unit

    attributes: final
    definition classes: AnyRef

64. #### def wait (arg0: Long, arg1: Int) : Unit

    attributes: final
    definition classes: AnyRef

65. #### def wait (arg0: Long) : Unit

    attributes: final
    definition classes: AnyRef

66. #### def | [U >: T] (q: ⇒ Parser[U]) : Parser[U]

    A parser combinator for alternative composition

    A parser combinator for alternative composition

    `p | q' succeeds if` p' succeeds or `q' succeeds Note that` q' is only tried if `p's failure is non-fatal (i.e., back-tracking is allowed).`

    q

      a parser that will be executed if `p' (this parser) fails (and allows back-tracking)`

    returns

      a `Parser' that returns the result of the first parser to succeed (out of` p' and `q') The resulting parser succeeds if (and only if) -` p' succeeds, or

      - if `p' fails allowing back-tracking and` q' succeeds.
    definition classes: Parser

67. #### def ||| [U >: T] (q0: ⇒ Parser[U]) : Parser[U]

    A parser combinator for alternative with longest match composition

    A parser combinator for alternative with longest match composition

    `p ||| q' succeeds if` p' succeeds or `q' succeeds If` p' and `q' both succeed, the parser that consumed the most characters accepts.`

    q0

      a parser that accepts if p consumes less characters. -- evaluated at most once, and only when necessary

    returns

      a `Parser' that returns the result of the parser consuming the most characters (out of` p' and `q').`

    definition classes: Parser

68. #### def ~ [U] (q: ⇒ Parser[U]) : Parser[~[T, U]]

    A parser combinator for sequential composition

    A parser combinator for sequential composition

    `p ~ q' succeeds if` p' succeeds and `q' succeeds on the input left over by` p'.

    q

      a parser that will be executed after `p' (this parser) succeeds -- evaluated at most once, and only when necessary`

    returns

      a `Parser' that -- on success -- returns a` ~' (like a Pair, but easier to pattern match on) that contains the result of `p' and that of` q'. The resulting parser fails if either `p' or` q' fails.

    definition classes: Parser

69. #### def ~! [U] (p: ⇒ Parser[U]) : Parser[~[T, U]]

    A parser combinator for non-back-tracking sequential composition

    A parser combinator for non-back-tracking sequential composition

    `p ~! q' succeeds if` p' succeeds and `q' succeeds on the input left over by` p'. In case of failure, no back-tracking is performed (in an earlier parser produced by the | combinator).

    returns

      a `Parser' that -- on success -- returns a` ~' (like a Pair, but easier to pattern match on) that contains the result of `p' and that of` q'. The resulting parser fails if either `p' or` q' fails, this failure is fatal.

    definition classes: Parser

70. #### def ~< [B] (other: Parser[B]) : Parser[~[T, B]]

    definition classes: ParserWithId

71. #### def ~< [B] (other: ParserWithId[B]) : ParserWithId[~[T, B]]

    definition classes: ParserWithId

72. #### def ~> [U] (q: ⇒ Parser[U]) : Parser[U]

    A parser combinator for sequential composition which keeps only the right result

    A parser combinator for sequential composition which keeps only the right result

    `p ~> q' succeeds if` p' succeeds and `q' succeeds on the input left over by` p'.

    q

      a parser that will be executed after `p' (this parser) succeeds -- evaluated at most once, and only when necessary`

    returns

      a `Parser' that -- on success -- returns the result of` q'.

    definition classes: Parser

### Inherited from Product

### Inherited from Equals

### Inherited from M[T]

### Inherited from MParser[T]

### Inherited from ParserWithId[T]

### Inherited from Parser[T]

### Inherited from (Input) ⇒ ParseResult[T]

### Inherited from AnyRef

### Inherited from Any