problems

type Attachments ¶

type Attachments []NamedData

type BytesData ¶

type BytesData struct {
	Loc string //Locale
	Val []byte //Value
	Typ string //Type (for example "text", "application/pdf", "text/html")
	Nam string //Name
}

func (s BytesData) IsHTML() bool

func (s BytesData) IsPDF() bool

func (s BytesData) IsText() bool

func (s BytesData) Locale() string

func (s BytesData) Name() string

func (s BytesData) String() string

func (s BytesData) Type() string

func (s BytesData) Value() ([]byte, error)

func (s BytesData) ValueReader() (io.ReadCloser, error)

type Checker ¶

type Checker interface {
	Check(testcase *Testcase) error
}

type ConfigIdentifier ¶

type ConfigIdentifier func(afero.Fs, string) bool

ConfigIdentifier is a function for some config type which takes a path and returns true if it thinks that its respective parser can parse it

type ConfigList ¶

type ConfigList struct {
	ConfigTypes []ProblemConfigType
}

func NewConfigList() *ConfigList

func (cs *ConfigList) Deregister(name string) error

func (cs *ConfigList) Parse(fs afero.Fs, path string) (Problem, error)

func (cs *ConfigList) Register(name string, parser ConfigParser, identifier ConfigIdentifier) error

type ConfigParser ¶

type ConfigParser func(afero.Fs, string) (Problem, error)

ConfigParser is a function for some config type which parses the problem from some path provided to it

type ConfigStore ¶

type ConfigStore interface {
	Register(string, ConfigParser, ConfigIdentifier) error
	Deregister(string) error

	Parse(afero.Fs, string) (Problem, error)
}

ConfigStore is an interface with which you can register/deregister certain config types and parse a problem using these config types

type Contents ¶

type Contents []LocalizedData

func (cs Contents) FilterByLocale(locale string) Contents

func (cs Contents) FilterByType(mime string) Contents

func (cs Contents) Locales() []string

type Data ¶

type Data interface {
	Value() ([]byte, error)
	ValueReader() (io.ReadCloser, error)
	Type() string
	IsText() bool
	IsHTML() bool
	IsPDF() bool
	fmt.Stringer
}

type FeedbackType ¶

type FeedbackType int

FeedbackType is mainly for displaying to the end user. In FeedbackCF we actually output the contestant's output and the jury's output, too whereas in for example FeedbackACM we only use standard ACM feedback (just the verdict), in FeedbackIOI we display all testcases along information about groups.

const (
	FeedbackCF FeedbackType = iota
	FeedbackIOI
	FeedbackACM
	FeedbackLazyIOI
)

func FeedbackFromString(str string) FeedbackType

func (f FeedbackType) String() string

type File ¶

type File struct {
	Name string
	Role string
	Path string
}

type FsStore ¶

type FsStore struct {
	ByPath map[string]string

	sync.RWMutex
	// contains filtered or unexported fields
}

func NewFsStore(root string, options ...FsStoreOptions) *FsStore

func (s *FsStore) Get(p string) (Problem, error)

func (s *FsStore) Has(p string) (bool, error)

func (s *FsStore) List() ([]string, error)

func (s *FsStore) MustGet(p string) Problem

func (s *FsStore) Update() error

func (s *FsStore) UpdateProblem(path string, name string) error

type FsStoreOptions ¶

type FsStoreOptions func(*FsStore)

func FsStoreIgnorePrefix() FsStoreOptions

func FsStoreUseConfigStore(cs ConfigStore) FsStoreOptions

func FsStoreUseFs(afs afero.Fs) FsStoreOptions

type Group ¶

type Group struct {
	Name         string
	Scoring      ScoringType
	Testcases    []Testcase
	Dependencies []string
}

A Group is named group of tests for which there is a scoring policy defined.

func (g Group) FirstNonAC() int

func (g Group) IsAC() bool

func (g Group) MaxMemoryUsage() int

func (g Group) MaxScore() float64

func (g Group) MaxTimeSpent() time.Duration

func (g Group) Score() float64

func (g *Group) SetMemoryLimit(ml int)

func (g *Group) SetTimeLimit(tl time.Duration)

type Judgeable ¶

type Judgeable interface {
	Checker() Checker
	InputOutputFiles() (string, string)
	Languages() []language.Language
	StatusSkeleton(testset string) (*Status, error)
	Files() []File
	GetTaskType() TaskType
}

type LocalizedData ¶

type LocalizedData interface {
	Data
	Locale() string
}

type NamedData ¶

type NamedData interface {
	Data
	Name() string
}

type Problem ¶

type Problem interface {
	Name() string
	Titles() Contents
	Statements() Contents
	MemoryLimit() int
	TimeLimit() int

	Attachments() Attachments
	Tags() []string

	Judgeable
}

func Parse(path string) (Problem, error)

type ProblemConfigType ¶

type ProblemConfigType struct {
	Name       string
	Parser     ConfigParser
	Identifier ConfigIdentifier
}

type ProblemNotFoundError ¶

type ProblemNotFoundError struct {
	Name string
}

func (perr ProblemNotFoundError) Error() string

func (perr ProblemNotFoundError) Is(target error) bool

type ProblemParseError ¶

type ProblemParseError struct {
	Errors   []error
	Problems []string
}

func (perr ProblemParseError) Error() string

func (perr ProblemParseError) Is(target error) bool

type ProblemWrapper ¶

type ProblemWrapper struct {
	Problem

	NameOverride string
}

func (pw ProblemWrapper) Name() string

type ScoringType ¶

type ScoringType int

ScoringType represents the scoring of a group of tests,

• ScoringGroup means that if there's a non-accepted (or partially accepted) testcase in the group then the whole group scores 0 points,
• ScoringSum means that the score of the group is the sum of scores of individual scores.

const (
	ScoringGroup ScoringType = iota
	ScoringSum
	ScoringMin
)

func ScoringFromString(str string) ScoringType

type Status ¶

type Status struct {
	Compiled       bool
	CompilerOutput string
	FeedbackType   FeedbackType
	Feedback       []Testset
}

A Status represents the status of a submission after judging It contains the information about compilation and the feedback The main Testset is always the first one in Feedback.

func (v *Status) Scan(value interface{}) error

func (v Status) Value() (driver.Value, error)

type Store ¶

type Store interface {
	List() ([]string, error)
	Has(string) (bool, error)
	Get(string) (Problem, error)
	MustGet(string) Problem
	Update() error
	UpdateProblem(path string, id string) error
}

Store is an interface which is used to access a bunch of problems for example from the filesystem

type TaskType ¶

type TaskType interface {
	Name() string
	Compile(Judgeable, language.Sandbox, language.Language, io.Reader, io.Writer) (io.Reader, error)
	Run(Judgeable, *language.SandboxProvider, language.Language, io.Reader, chan string, chan Status) (Status, error)
}

func GetTaskType(name string) (TaskType, error)

type Testcase ¶

type Testcase struct {
	Index          int
	InputPath      string
	OutputPath     string
	AnswerPath     string
	Testset        string
	Group          string
	VerdictName    VerdictName
	Score          float64
	MaxScore       float64
	Output         string
	ExpectedOutput string
	CheckerOutput  string
	TimeSpent      time.Duration
	MemoryUsed     int
	TimeLimit      time.Duration
	MemoryLimit    int
}

Testcase represents a testcase in the status of a submission.

type Testset ¶

type Testset struct {
	Name   string
	Groups []Group
}

Testset represents some set of tests, for example pretests and system tests should be testsets. They can also be used to seamlessly rejudge for contestants.

func (ts Testset) FirstNonAC() int

func (ts Testset) IndexTestcase(ind int) *Testcase

func (ts Testset) IsAC() bool

func (ts Testset) MaxMemoryUsage() int

func (ts Testset) MaxScore() (res float64)

func (ts Testset) MaxTimeSpent() time.Duration

func (ts Testset) Score() (res float64)

func (ts *Testset) SetMemoryLimit(ml int)

func (ts *Testset) SetTimeLimit(tl time.Duration)

func (ts Testset) Testcases() (testcases []*Testcase)

func (ts Testset) Verdict() VerdictName

type VerdictName ¶

type VerdictName int

VerdictName represents the verdict of a testcase i.e the outcome which happened in result of running the testcase (or the lack of running it in the case of VerdictDR)

const (
	VerdictAC VerdictName = iota
	VerdictWA
	VerdictRE
	VerdictTL
	VerdictML
	VerdictXX
	VerdictDR
	VerdictPC
	VerdictPE
)

func (v VerdictName) String() string