services

type Factory interface {
	// FromString fill factory with data parsed from connection string.
	//
	// The connection string will be parsed by the following format:
	//
	//     s3://<credential>@<endpoint>/<name>/<work_dir>?force_path_style
	FromString(conn string) (err error)
	// FromMap fill factory with data parsed from map.
	//
	// The map will be parsed by the following format:
	//
	//   {
	//		"credential": <credential>,
	//		"endpoint": <endpoint>,
	//		"name": <name>,
	//		"work_dir": <work_dir>,
	//		"force_path_style": true
	//   }
	FromMap(m map[string]interface{}) (err error)
	// WithPairs fill factory with data parsed from key-value pairs.
	WithPairs(ps ...types.Pair) (err error)

	// NewServicer will create a new service via already initialized factory.
	//
	// Service should implement `newService() (*Service, error)`
	//
	// It's possible that the factory only support init Storager, but not init Servicer.
	// For example, services like `fs` only have Storager but no Servicer support.
	// We will generate an error for it.
	NewServicer() (srv types.Servicer, err error)
	// NewStorager will create a new storage via already initialized factory.
	//
	// Service should implement `newStorage() (*Storage, error)`
	//
	// It's possible that the factory is OK to NewServicer but not OK to NewStorager.
	// For example, services like `s3` will fail to init a storager will user doesn't input a bucket name.
	// We will generate an error for it.
	NewStorager() (sto types.Storager, err error)
}

type InitError struct {
	Op   string
	Type string
	Err  error

	Pairs []types.Pair
}

type InternalError interface {
	// IsInternalError SHOULD and SHOULD ONLY be implemented by error definitions in go-storage & go-service-*.
	// We depends on the InternalError interface to distinguish our errors.
	// There's no need for user code to implement or use this function and interface.
	IsInternalError()
}

type ListModeInvalidError struct {
	Actual types.ListMode
}

type MetadataUnrecognizedError struct {
	Key   string
	Value interface{}
}

type NewServicerFunc func(ps ...types.Pair) (types.Servicer, error)

type NewStoragerFunc func(ps ...types.Pair) (types.Storager, error)

type ObjectModeInvalidError struct {
	Expected types.ObjectMode
	Actual   types.ObjectMode
}

type PairRequiredError struct {
	Keys []string
}

type PairUnsupportedError struct {
	Pair types.Pair
}

type ServiceError struct {
	Op  string
	Err error

	types.Servicer
	Name string
}

type StorageError struct {
	Op  string
	Err error

	types.Storager
	Path []string
}