Initial QSfera import

Server/vendor/github.com/CiscoM31/godata/request_model.go

@@ -0,0 +1,241 @@
+package godata
+
+type GoDataIdentifier map[string]string
+
+type RequestKind int
+
+const (
+	RequestKindUnknown RequestKind = iota
+	RequestKindMetadata
+	RequestKindService
+	RequestKindEntity
+	RequestKindCollection
+	RequestKindSingleton
+	RequestKindProperty
+	RequestKindPropertyValue
+	RequestKindRef
+	RequestKindCount
+)
+
+type SemanticType int
+
+const (
+	SemanticTypeUnknown SemanticType = iota
+	SemanticTypeEntity
+	SemanticTypeEntitySet
+	SemanticTypeDerivedEntity
+	SemanticTypeAction
+	SemanticTypeFunction
+	SemanticTypeProperty
+	SemanticTypePropertyValue
+	SemanticTypeRef
+	SemanticTypeCount
+	SemanticTypeMetadata
+)
+
+type GoDataRequest struct {
+	FirstSegment *GoDataSegment
+	LastSegment  *GoDataSegment
+	Query        *GoDataQuery
+	RequestKind  RequestKind
+}
+
+// Represents a segment (slash-separated) part of the URI path. Each segment
+// has a link to the next segment (the last segment precedes nil).
+type GoDataSegment struct {
+	// The raw segment parsed from the URI
+	RawValue string
+
+	// The kind of resource being pointed at by this segment
+	SemanticType SemanticType
+
+	// A pointer to the metadata type this object represents, as defined by a
+	// particular service
+	SemanticReference interface{}
+
+	// The name of the entity, type, collection, etc.
+	Name string
+
+	// map[string]string of identifiers passed to this segment. If the identifier
+	// is not key/value pair(s), then all values will be nil. If there is no
+	// identifier, it will be nil.
+	Identifier *GoDataIdentifier
+
+	// The next segment in the path.
+	Next *GoDataSegment
+	// The previous segment in the path.
+	Prev *GoDataSegment
+}
+
+type GoDataQuery struct {
+	Filter      *GoDataFilterQuery
+	At          *GoDataFilterQuery
+	Apply       *GoDataApplyQuery
+	Expand      *GoDataExpandQuery
+	Select      *GoDataSelectQuery
+	OrderBy     *GoDataOrderByQuery
+	Top         *GoDataTopQuery
+	Skip        *GoDataSkipQuery
+	Count       *GoDataCountQuery
+	InlineCount *GoDataInlineCountQuery
+	Search      *GoDataSearchQuery
+	Compute     *GoDataComputeQuery
+	Format      *GoDataFormatQuery
+}
+
+// GoDataExpression encapsulates the tree representation of an expression
+// as defined in the OData ABNF grammar.
+type GoDataExpression struct {
+	Tree *ParseNode
+	// The raw string representing an expression
+	RawValue string
+}
+
+// Stores a parsed version of the filter query string. Can be used by
+// providers to apply the filter based on their own implementation. The filter
+// is stored as a parse tree that can be traversed.
+type GoDataFilterQuery struct {
+	Tree *ParseNode
+	// The raw filter string
+	RawValue string
+}
+
+type GoDataApplyQuery string
+
+type GoDataExpandQuery struct {
+	ExpandItems []*ExpandItem
+}
+
+type GoDataSelectQuery struct {
+	SelectItems []*SelectItem
+	// The raw select string
+	RawValue string
+}
+
+type GoDataOrderByQuery struct {
+	OrderByItems []*OrderByItem
+	// The raw orderby string
+	RawValue string
+}
+
+type GoDataTopQuery int
+
+type GoDataSkipQuery int
+
+type GoDataCountQuery bool
+
+type GoDataInlineCountQuery string
+
+type GoDataSearchQuery struct {
+	Tree *ParseNode
+	// The raw search string
+	RawValue string
+}
+
+type GoDataComputeQuery struct {
+	ComputeItems []*ComputeItem
+	// The raw compute string
+	RawValue string
+}
+
+type GoDataFormatQuery struct {
+}
+
+// Check if this identifier has more than one key/value pair.
+func (id *GoDataIdentifier) HasMultiple() bool {
+	count := 0
+	for range map[string]string(*id) {
+		count++
+	}
+	return count > 1
+}
+
+// Return the first key in the map. This is how you should get the identifier
+// for single values, e.g. when the path is Employee(1), etc.
+func (id *GoDataIdentifier) Get() string {
+	for k := range map[string]string(*id) {
+		return k
+	}
+	return ""
+}
+
+// Return a specific value for a specific key.
+func (id *GoDataIdentifier) GetKey(key string) (string, bool) {
+	v, ok := map[string]string(*id)[key]
+	return v, ok
+}
+
+// GoDataCommonStructure represents either a GoDataQuery or ExpandItem in a uniform manner
+// as a Go interface. This allows the writing of functional logic that can work on either type,
+// such as a provider implementation which starts at the GoDataQuery and walks any nested ExpandItem
+// in an identical manner.
+type GoDataCommonStructure interface {
+	GetFilter() *GoDataFilterQuery
+	GetAt() *GoDataFilterQuery
+	GetApply() *GoDataApplyQuery
+	GetExpand() *GoDataExpandQuery
+	GetSelect() *GoDataSelectQuery
+	GetOrderBy() *GoDataOrderByQuery
+	GetTop() *GoDataTopQuery
+	GetSkip() *GoDataSkipQuery
+	GetCount() *GoDataCountQuery
+	GetInlineCount() *GoDataInlineCountQuery
+	GetSearch() *GoDataSearchQuery
+	GetCompute() *GoDataComputeQuery
+	GetFormat() *GoDataFormatQuery
+	// AddExpandItem adds an item to the list of expand clauses in the underlying GoDataQuery/ExpandItem
+	// structure.
+	// AddExpandItem may be used to add items based on the requirements of the application using godata.
+	// For example applications may support the introduction of dynamic navigational fields using $compute.
+	// A possible implementation is to parse the request url using godata and then during semantic
+	// post-processing identify dynamic navigation properties and call AddExpandItem to add them to the
+	// list of expanded fields.
+	AddExpandItem(*ExpandItem)
+}
+
+// GoDataQuery implementation of GoDataCommonStructure interface
+func (o *GoDataQuery) GetFilter() *GoDataFilterQuery           { return o.Filter }
+func (o *GoDataQuery) GetAt() *GoDataFilterQuery               { return o.At }
+func (o *GoDataQuery) GetApply() *GoDataApplyQuery             { return o.Apply }
+func (o *GoDataQuery) GetExpand() *GoDataExpandQuery           { return o.Expand }
+func (o *GoDataQuery) GetSelect() *GoDataSelectQuery           { return o.Select }
+func (o *GoDataQuery) GetOrderBy() *GoDataOrderByQuery         { return o.OrderBy }
+func (o *GoDataQuery) GetTop() *GoDataTopQuery                 { return o.Top }
+func (o *GoDataQuery) GetSkip() *GoDataSkipQuery               { return o.Skip }
+func (o *GoDataQuery) GetCount() *GoDataCountQuery             { return o.Count }
+func (o *GoDataQuery) GetInlineCount() *GoDataInlineCountQuery { return o.InlineCount }
+func (o *GoDataQuery) GetSearch() *GoDataSearchQuery           { return o.Search }
+func (o *GoDataQuery) GetCompute() *GoDataComputeQuery         { return o.Compute }
+func (o *GoDataQuery) GetFormat() *GoDataFormatQuery           { return o.Format }
+
+// AddExpandItem adds an expand clause to the toplevel odata request structure 'o'.
+func (o *GoDataQuery) AddExpandItem(item *ExpandItem) {
+	if o.Expand == nil {
+		o.Expand = &GoDataExpandQuery{}
+	}
+	o.Expand.ExpandItems = append(o.Expand.ExpandItems, item)
+}
+
+// ExpandItem implementation of GoDataCommonStructure interface
+func (o *ExpandItem) GetFilter() *GoDataFilterQuery           { return o.Filter }
+func (o *ExpandItem) GetAt() *GoDataFilterQuery               { return o.At }
+func (o *ExpandItem) GetApply() *GoDataApplyQuery             { return nil }
+func (o *ExpandItem) GetExpand() *GoDataExpandQuery           { return o.Expand }
+func (o *ExpandItem) GetSelect() *GoDataSelectQuery           { return o.Select }
+func (o *ExpandItem) GetOrderBy() *GoDataOrderByQuery         { return o.OrderBy }
+func (o *ExpandItem) GetTop() *GoDataTopQuery                 { return o.Top }
+func (o *ExpandItem) GetSkip() *GoDataSkipQuery               { return o.Skip }
+func (o *ExpandItem) GetCount() *GoDataCountQuery             { return nil }
+func (o *ExpandItem) GetInlineCount() *GoDataInlineCountQuery { return nil }
+func (o *ExpandItem) GetSearch() *GoDataSearchQuery           { return o.Search }
+func (o *ExpandItem) GetCompute() *GoDataComputeQuery         { return o.Compute }
+func (o *ExpandItem) GetFormat() *GoDataFormatQuery           { return nil }
+
+// AddExpandItem adds an expand clause to 'o' creating a nested expand, ie $expand 'item'
+// nested within $expand 'o'.
+func (o *ExpandItem) AddExpandItem(item *ExpandItem) {
+	if o.Expand == nil {
+		o.Expand = &GoDataExpandQuery{}
+	}
+	o.Expand.ExpandItems = append(o.Expand.ExpandItems, item)
+}