parser

Documentation

Index

• Constants
• Variables
• func IsPackedList(value string) bool
• func UnpackedList(value string) string
• type Class
  • func (c *Class) Dump()
  • func (c *Class) GetAllBases() []string
  • func (c *Class) GetBases() []string
  • func (c *Class) HasFunctionWithName(name string) bool
  • func (c *Class) IsQObjectSubClass() bool
  • func (c *Class) IsSubClass(class string) bool
• type Enum
  • func (e *Enum) Class() string
• type Function
  • func (f *Function) Class() string
• type Module
  • func GetModule(s string) (m *Module, err error)
  • func (m *Module) Prepare()
• type Namespace
• type Parameter
• type SubNamespace
• type Value
• type Variable
  • func (v *Variable) Class() string

Constants

const (
	SIGNAL = "signal"
	SLOT   = "slot"

	IMPURE = "impure"
	PURE   = "pure"

	MOC              = "main"
	PLAIN            = "plain"
	CONSTRUCTOR      = "constructor"
	COPY_CONSTRUCTOR = "copy-constructor"
	MOVE_CONSTRUCTOR = "move-constructor"
	DESTRUCTOR       = "destructor"

	CONNECT    = "Connect"
	DISCONNECT = "Disconnect"
	CALLBACK   = "callback"

	GETTER = "getter"
	SETTER = "setter"

	VOID = "void"

	TILDE = "~"
)

Variables

var (
	ClassMap        = make(map[string]*Class)
	SubnamespaceMap = make(map[string]bool)
)

var LibDeps = map[string][]string{
	"Core":          {"Widgets", "Gui"},
	"AndroidExtras": {"Core"},
	"Gui":           {"Widgets", "Core"},
	"Network":       {"Core"},
	"Xml":           {"XmlPatterns", "Core"},
	"DBus":          {"Core"},
	"Nfc":           {"Core"},
	"Script":        {"Core"},
	"Sensors":       {"Core"},
	"Positioning":   {"Core"},
	"Widgets":       {"Gui", "Core"},
	"Sql":           {"Widgets", "Gui", "Core"},
	"MacExtras":     {"Gui", "Core"},
	"Qml":           {"Network", "Core"},
	"WebSockets":    {"Network", "Core"},
	"XmlPatterns":   {"Network", "Core"},
	"Bluetooth":     {"Core"},
	"WebChannel":    {"Network", "Qml", "Core"},
	"Svg":           {"Widgets", "Gui", "Core"},
	"Multimedia":    {"MultimediaWidgets", "Widgets", "Network", "Gui", "Core"},
	"Quick":         {"QuickWidgets", "Widgets", "Network", "Qml", "Gui", "Core"},
	"Help":          {"Sql", "CLucene", "Network", "Widgets", "Gui", "Core"},
	"Location":      {"Positioning", "Quick", "Gui", "Core"},
	"ScriptTools":   {"Script", "Widgets", "Core"},
	"UiTools":       {"Widgets", "Gui", "Core"},
	"X11Extras":     {"Gui", "Core"},
	"WinExtras":     {"Gui", "Core"},
	"WebEngine":     {"Widgets", "WebEngineWidgets", "WebChannel", "Network", "WebEngineCore", "Quick", "Gui", "Qml", "Core"},
	"TestLib":       {"Widgets", "Gui", "Core"},
	"SerialPort":    {"Core"},
	"SerialBus":     {"Core"},
	"PrintSupport":  {"Widgets", "Gui", "Core"},

	"Designer": {"UiPlugin", "Widgets", "Gui", "Xml", "Core"},
	"Scxml":    {"Network", "Qml", "Core"},
	"Gamepad":  {"Gui", "Core"},

	"Purchasing": {"Core"},

	"Sailfish": {"Core"},

	MOC:         make([]string, 0),
	"build_ios": {"Core", "Gui", "Network", "Sql", "Xml", "DBus", "Nfc", "Script", "Sensors", "Positioning", "Widgets", "Qml", "WebSockets", "XmlPatterns", "Bluetooth", "WebChannel", "Svg", "Multimedia", "Quick", "Help", "Location", "ScriptTools", "MultimediaWidgets", "UiTools", "PrintSupport"},
}

Functions

func IsPackedList

func IsPackedList(value string) bool

func UnpackedList

func UnpackedList(value string) string

Types

type Class

type Class struct {
	Name       string      `xml:"name,attr"`
	Status     string      `xml:"status,attr"`
	Access     string      `xml:"access,attr"`
	Abstract   bool        `xml:"abstract,attr"`
	Bases      string      `xml:"bases,attr"`
	Module     string      `xml:"module,attr"`
	Brief      string      `xml:"brief,attr"`
	Functions  []*Function `xml:"function"`
	Enums      []*Enum     `xml:"enum"`
	Variables  []*Variable `xml:"variable"`
	Properties []*Variable `xml:"property"`
	DocModule  string
	Stub       bool
	WeakLink   map[string]bool
	Export     bool
}

func (*Class) Dump

func (c *Class) Dump()

func (*Class) GetAllBases

func (c *Class) GetAllBases() []string

func (*Class) GetBases

func (c *Class) GetBases() []string

func (*Class) HasFunctionWithName

func (c *Class) HasFunctionWithName(name string) bool

func (*Class) IsQObjectSubClass

func (c *Class) IsQObjectSubClass() bool

func (*Class) IsSubClass

func (c *Class) IsSubClass(class string) bool

type Enum

type Enum struct {
	Name     string   `xml:"name,attr"`
	Fullname string   `xml:"fullname,attr"`
	Status   string   `xml:"status,attr"`
	Access   string   `xml:"access,attr"`
	Typedef  string   `xml:"typedef,attr"`
	Values   []*Value `xml:"value"`
	NoConst  bool
}

func (*Enum) Class

func (e *Enum) Class() string

type Function

type Function struct {
	Name            string       `xml:"name,attr"`
	Fullname        string       `xml:"fullname,attr"`
	Href            string       `xml:"href,attr"`
	Status          string       `xml:"status,attr"`
	Access          string       `xml:"access,attr"`
	Filepath        string       `xml:"filepath,attr"`
	Virtual         string       `xml:"virtual,attr"`
	Meta            string       `xml:"meta,attr"`
	Static          bool         `xml:"static,attr"`
	Overload        bool         `xml:"overload,attr"`
	OverloadNumber  string       `xml:"overload-number,attr"`
	Output          string       `xml:"type,attr"`
	Signature       string       `xml:"signature,attr"`
	Parameters      []*Parameter `xml:"parameter"`
	Brief           string       `xml:"brief,attr"`
	SignalMode      string
	TemplateModeJNI string
	Default         bool
	TmpName         string
	Export          bool
	NeedsFinalizer  bool
	Container       string
	TemplateModeGo  string
	Child           *Function
	NonMember       bool
	NoMocDeduce     bool
}

func (*Function) Class

func (f *Function) Class() string

type Module

type Module struct {
	Namespace *Namespace `xml:"namespace"`
	Project   string     `xml:"project,attr"`
}

func GetModule

func GetModule(s string) (m *Module, err error)

func (*Module) Prepare

func (m *Module) Prepare()

type Namespace

type Namespace struct {
	Classes []*Class `xml:"class"`
	//Functions    []*Function   `xml:"function"`
	SubNamespace *SubNamespace `xml:"namespace"`
}

type Parameter

type Parameter struct {
	Name  string `xml:"name,attr"`
	Value string `xml:"left,attr"`
}

type SubNamespace

type SubNamespace struct {
	//Classes   []*Class    `xml:"class"`
	//Functions []*Function `xml:"function"`
	Enums []*Enum `xml:"enum"`
}

type Value

type Value struct {
	Name  string `xml:"name,attr"`
	Value string `xml:"value,attr"`
}

type Variable

type Variable struct {
	Name     string    `xml:"name,attr"`
	Fullname string    `xml:"fullname,attr"`
	Href     string    `xml:"href,attr"`
	Status   string    `xml:"status,attr"`
	Access   string    `xml:"access,attr"`
	Filepath string    `xml:"filepath,attr"`
	Static   bool      `xml:"static,attr"`
	Output   string    `xml:"type,attr"`
	Brief    string    `xml:"brief,attr"`
	Getter   []*getter `xml:"getter"`
	Setter   []*setter `xml:"setter"`
}

func (*Variable) Class

func (v *Variable) Class() string