package YAML::Tokens;
use strict;
use warnings;
use YAML::Base -base;

#>  class Token(object):
#>      def __init__(self, start_mark, end_mark):
#>          self.start_mark = start_mark
#>          self.end_mark = end_mark
#>      def __repr__(self):
#>          attributes = [key for key in self.__dict__
#>                  if not key.endswith('_mark')]
#>          attributes.sort()
#>          arguments = ', '.join(['%s=%r' % (key, getattr(self, key))
#>                  for key in attributes])
#>          return '%s(%s)' % (self.__class__.__name__, arguments)

package YAML::Token;
use YAML::Base -base;

field 'start_mark';
field 'end_mark';

use overload '""' => 'stringify';

sub stringify {
    my $self = shift;
    my $class = ref($self) || $self;

    my @attributes = grep not(/_mark$/), keys %$self;
    my $arguments = join ', ', map
        sprintf("%s=%s", $_, $self->{$_}), @attributes;
    return "$class ($arguments)";
}

#>  #class BOMToken(Token):
#>  #    id = '<byte order mark>'
#>  
#>  class DirectiveToken(Token):
#>      id = '<directive>'
#>      def __init__(self, name, value, start_mark, end_mark):
#>          self.name = name
#>          self.value = value
#>          self.start_mark = start_mark
#>          self.end_mark = end_mark

package YAML::Token::Directive;
use YAML::Token -base;

field id => '<directive>';
field 'name';
field 'value';

#>  class DocumentStartToken(Token):
#>      id = '<document start>'

package YAML::Token::DocumentStart;
use YAML::Token -base;

field id => '<document start>';

#>  class DocumentEndToken(Token):
#>      id = '<document end>'

package YAML::Token::DocumentEnd;
use YAML::Token -base;

field id => '<document end>';

#>  class StreamStartToken(Token):
#>      id = '<stream start>'
#>      def __init__(self, start_mark=None, end_mark=None,
#>              encoding=None):
#>          self.start_mark = start_mark
#>          self.end_mark = end_mark
#>          self.encoding = encoding

package YAML::Token::StreamStart;
use YAML::Token -base;

field id => '<stream start>';
field 'encoding';

#>  class StreamEndToken(Token):
#>      id = '<stream end>'

package YAML::Token::StreamEnd;
use YAML::Token -base;

field id => '<stream end>';

#>  class BlockSequenceStartToken(Token):
#>      id = '<block sequence start>'

package YAML::Token::BlockSequenceStart;
use YAML::Token -base;

field id => '<block sequence start>';

#>  class BlockMappingStartToken(Token):
#>      id = '<block mapping start>'

package YAML::Token::BlockMappingStart;
use YAML::Token -base;

field id => '<block mapping start>';

#>  class BlockEndToken(Token):
#>      id = '<block end>'

package YAML::Token::BlockEnd;
use YAML::Token -base;

field id => '<block end>';

#>  class FlowSequenceStartToken(Token):
#>      id = '['

package YAML::Token::FlowSequenceStart;
use YAML::Token -base;

field id => '[';

#>  class FlowMappingStartToken(Token):
#>      id = '{'

package YAML::Token::FlowMappingStart;
use YAML::Token -base;

field id => '{';

#>  class FlowSequenceEndToken(Token):
#>      id = ']'

package YAML::Token::FlowSequenceEnd;
use YAML::Token -base;

field id => ']';

#>  class FlowMappingEndToken(Token):
#>      id = '}'

package YAML::Token::FlowMappingEnd;
use YAML::Token -base;

field id => '}';

#>  class KeyToken(Token):
#>      id = '?'

package YAML::Token::Key;
use YAML::Token -base;

field id => '?';

#>  class ValueToken(Token):
#>      id = ':'

package YAML::Token::Value;
use YAML::Token -base;

field id => ':';

#>  class BlockEntryToken(Token):
#>      id = '-'

package YAML::Token::BlockEntry;
use YAML::Token -base;

field id => '-';

#>  class FlowEntryToken(Token):
#>      id = ','

package YAML::Token::FlowEntry;
use YAML::Token -base;

field id => ',';

# class AliasToken(Token):
#     id = '<alias>'
#     def __init__(self, value, start_mark, end_mark):
#         self.value = value
#         self.start_mark = start_mark
#         self.end_mark = end_mark

package YAML::Token::Alias;
use YAML::Token -base;

field id => '<alias>';
field 'value';

# class AnchorToken(Token):
#     id = '<anchor>'
#     def __init__(self, value, start_mark, end_mark):
#         self.value = value
#         self.start_mark = start_mark
#         self.end_mark = end_mark

package YAML::Token::Anchor;
use YAML::Token -base;

field id => '<anchor>';
field 'value';

# class TagToken(Token):
#     id = '<tag>'
#     def __init__(self, value, start_mark, end_mark):
#         self.value = value
#         self.start_mark = start_mark
#         self.end_mark = end_mark

package YAML::Token::Tag;
use YAML::Token -base;

field id => '<tag>';
field 'value';

# class ScalarToken(Token):
#     id = '<scalar>'
#     def __init__(self, value, plain, start_mark, end_mark, style=None):
#         self.value = value
#         self.plain = plain
#         self.start_mark = start_mark
#         self.end_mark = end_mark
#         self.style = style

package YAML::Token::Scalar;
use YAML::Token -base;

field id => '<scalar>';
field 'value';
field 'plain';
field 'style';

1;