propchange

type ChangeFilter struct {
	Document    string
	NewDocument bool
	Properties  map[string]uint64
}

type Detector interface {
	// OpenDocument opens a document to perform
	// operation on the document
	OpenDocument(ctx context.Context, name string) (DocumentOps, error)

	// AddListener creates or updates a listener, that watches for properties to change.
	// If a listener already exists, that listeners gets updated. The given filter
	// is simply "appended" to the already existing listener. So if the existing listener
	// listened to doc "A", and the "new" listener filtered for doc "B", the updated
	// listener listens for document "A" and "B".
	// If a document or property does not exist, the listener will get instantly triggered.
	// This is because the property or document maybe existed, but got deleted in the meantime.
	// If it's known that a document does not exist, instead of listening for properties, the
	// listener can listen for document creation. A filter can either listen for the creation of
	// the document or for properties. This is because the filter would always trigger right away
	// if the document already exists.
	AddListener(ctx context.Context, name string, filter []ChangeFilter) error

	// GetListener gets the filter that represents a given listener. This function is basically there
	// to check whether a listener / filter exists. The returned filter might not represent the full
	// added filter. This can happen if a listener listens to non existing properties or documents.
	// Also, an already triggered listener might be returned as not existing.
	GetListener(ctx context.Context, name string) ([]ChangeFilter, error)

	// DelListener deletes a given listener. If the listeners does not exist, it is silently ignored.
	DelListener(ctx context.Context, listener string) error

	// NextChange returns the next change that was not
	// yet processed
	NextChange(ctx context.Context) (OnChange, error)
}

type DocumentOps interface {
	// IsNew tells that commiting this document,
	// causes to create a new document.
	IsNew() bool

	// GetProperties gets the current set properties
	GetProperties() map[string]uint64

	// DelProperty deletes the given property.
	// Deletion of a property does trigger a change. To simply update
	// a property use the set Property method again. SetProperty overwrite
	// any previous value. The property does not have to be deleted beforehand.
	DelProperty(name string) error

	// SetProperty sets a new Property or overwrites an existing one.
	// This will later trigger a change event, if the rev value is
	// greater than a given filter.
	// Note: The value should always atomically increase. Otherwise
	// changes would not trigger an event. However, less values are
	// ignored automatically. This prevents race conditions if,
	// two changes of the same property happened close to each other.
	// If change with rev (3) arrived earlier than change of rev (2),
	// only one change event will trigger -> the rev (3).
	// but this is fine, because rev (2) is in that moment already
	// outdated.
	SetProperty(name string, rev uint64) error

	// Delete deletes the whole document. Deletion does trigger a change.
	// Delete does an implicit Commit(). No additional operations are possible.
	Delete() error

	// Commit applies all changes done with DelProperty and SetProperty.
	// No close needed. No additional operations are possible.
	Commit() error

	// Close closes the document without committing any changes.
	// No additional operations are possible.
	Close() error
}

type ErrInvalidPropertyName string

type ErrListenerDoesNotExist string

type ErrTooLongName struct {
	Name string

	// Len is used if len(Name) does not reflect the real
	// current length. It could be different because of charset
	// converstions or other detector specifications.
	Len    int
	MaxLen int
}

type OnChange interface {
	// Documents which are attached to this event
	// This inclues all documents that the listener registered to,
	// not just the document of which properties changed.
	Documents() []string
	// Listener which listened for the change
	Listener() string
	// Commit confirms that the event was processed.
	// The listener is removed from the system.
	Commit() error
	// Close closes but not commits the event.
	// The event will be later triggered again.
	Close() error
}