Components

import { 
    Parameters, ConfigParams, 
    Descriptor, ICleanable, IConfigurable, 
    IExecutable, INotifiable, IOpenable, 
    IReferenceable, IReferences, 
    IUnreferenceable 
} from "pip-services3-commons-nodex";

class MyComponent implements IConfigurable, IReferenceable, IUnreferenceable, IOpenable, IExecutable, INotifiable, ICleanable {
    public constructor() { /* Initialize the component */ }
    public configure(config: ConfigParams) { /* configure the component */ }
    public setReferences(refs: IReferences) { /* set component dependencies */ }
    public unsetReferences() { /* unset component references */ }
    public isOpen(): boolean { /* return the component open state */ }
    public open(correlationId: string): Promise<void> { /* open the component */ }
    public close(correlationId: string): Promise<void> { /* close the component */ }
    public execute(correlationId: string, args: Parameters): Promise<any> { /* execute the component transaction */ }
    public notify(correlationId: string, args: Parameters) { /* notify the component about events */ }
    public clear(correlationId: string): Promise<void> { /* clear the component state */ }
}

using PipServices3.Commons.Config;
using PipServices3.Commons.Refer;
using PipServices3.Commons.Run;
using System.Threading.Tasks;

public class MyComponent: IConfigurable, IReferenceable, IUnreferenceable, IOpenable, IExecutable, INotifiable, 
ICleanable
{
    public MyComponent() { /* Initialize the component */ }
    public void Configure(ConfigParams config) { /* configure the component */ }
    public void SetReferences(IReferences references) { /* set component dependencies */ }
    public void UnsetReferences() { /* unset component references */ }
    public bool IsOpen() { /* return the component open state */ }
    public Task OpenAsync(string correlationId) { /* open the component */ }
    public Task CloseAsync(string correlationId) { /* close the component */ }
    public Task<object> ExecuteAsync(string correlationId, Parameters args) { /* execute the component 
transaction */ }
    public Task NotifyAsync(string correlationId, Parameters args) { /* notify the component about events*/ }
    public Task ClearAsync(string correlationId) { /* clear the component state */ }
}

import (
	cconf "github.com/pip-services3-gox/pip-services3-commons-gox/config"
	cref "github.com/pip-services3-gox/pip-services3-commons-gox/refer"
	crun "github.com/pip-services3-gox/pip-services3-commons-gox/run"

	// ------------
	cproc "github.com/pip-services3-gox/pip-services3-container-gox/container"
	gbuild "github.com/pip-services3-gox/pip-services3-grpc-gox/build"
	rbuild "github.com/pip-services3-gox/pip-services3-rpc-gox/build"
	factory "github.com/pip-templates/pip-templates-microservice-go/build"
)

// Implements IConfigurable, IReferenceable, IUnreferenceable, IOpenable, IExecutable, INotifiable, ICleanable
type MyComponent struct{}

func (c *MyComponent) NewMyComponent() { /* Initialize the component */ }

func (c *MyComponent) Configure(ctx context.Context, config *cconf.ConfigParams) { /* configure the component */ }

func (c *MyComponent) SetReferences(ctx context.Context, refs cref.IReferences) { /* set component dependencies */ }

func (c *MyComponent) UnsetReferences() { /* unset component references */ }

func (c *MyComponent) IsOpen() bool { /* return the component open state */ }

func (c *MyComponent) Open(ctx context.Context, correlationId string) error { /* open the component */ }

func (c *MyComponent) Close(ctx context.Context, correlationId string) error { /* close the component */ }

func (c *MyComponent) Execute(ctx context.Context, correlationId string, args *crun.Parameters) error { /* execute the component transaction */
}

func (c *MyComponent) Notify(ctx context.Context, correlationId string, args *crun.Parameters) { /* notify the component about events */
}

func (c *MyComponent) Clear(ctx context.Context, correlationId string) error { /* clear the component state */ }

import 'package:pip_services3_commons/pip_services3_commons.dart';

class MyComponent
    implements
        IConfigurable,
        IReferenceable,
        IUnreferenceable,
        IOpenable,
        IExecutable,
        INotifiable,
        ICleanable {

  MyComponent() {/* Initialize the component */}
  @override
  void configure(ConfigParams config) {/* configure the component */}

  @override
  void setReferences(IReferences references) {/* set component dependencies */}

  @override
  void unsetReferences() {/* unset component references */}

  @override
  bool isOpen() {/* return the component open state */}

  @override
  Future open(String? correlationId) {/* open the component */}

  @override
  Future close(String? correlationId) {/* close the component */}

  @override
  Future execute(String? correlationId, Parameters args) { /* execute the component transaction */ }

  @override
  void notify(String? correlationId, Parameters args) { /* notify the component about events */ }

  @override
  Future clear(String? correlationId) {/* clear the component state */}
}

from typing import Optional

from pip_services3_commons.config import IConfigurable, ConfigParams
from pip_services3_commons.refer import IReferenceable, IUnreferenceable, IReferences
from pip_services3_commons.run import IOpenable, IExecutable, INotifiable, ICleanable, Parameters


class MyComponent(IConfigurable, IReferenceable, IUnreferenceable, IOpenable, IExecutable, INotifiable, ICleanable):

    def __init__(self):
        """Initialize the component"""
    def configure(self, config: ConfigParams):
        """configure the component"""

    def set_references(self, references: IReferences):
        """set component dependencies"""

    def unset_references(self):
        """unset component references"""

    def is_open(self) -> bool:
        """return the component open state"""

    def open(self, correlation_id: Optional[str]):
        """open the component"""

    def close(self, correlation_id: Optional[str]):
        """close the component"""

    def execute(self, correlation_id: Optional[str], args: Parameters):
        """execute the component transaction"""

    def notify(self, correlation_id: Optional[str], args: Parameters):
        """notify the component about events"""

    def clear(self, correlation_id: Optional[str]):
        """clear the component state"""

import { ProcessContainer } from "pip-services3-container-nodex";
import { DefaultGrpcFactory } from "pip-services3-grpc-nodex";
import { DefaultRpcFactory } from "pip-services3-rpc-nodex";
import { DefaultSwaggerFactory } from "pip-services3-swagger-nodex";


class MyProcess extends ProcessContainer {
    public constructor() {
        super('mymicroservice', 'Sample microservice container');

        this._factories.add(new MyComponentFactory());
        this._factories.add(new DefaultRpcFactory());
        this._factories.add(new DefaultSwaggerFactory());
        this._factories.add(new DefaultGrpcFactory());
    }
}

using PipServices3.Container;
using PipServices3.Grpc.Build;
using PipServices3.Rpc.Build;
using PipServices3.Swagger.Build;


public class MyProcess : ProcessContainer
{
    public MyProcess() : base("mymicroservice", "Sample microservice container")
    {
        this._factories.Add(new MyComponentFactory());
        this._factories.Add(new DefaultRpcFactory());
        this._factories.Add(new DefaultSwaggerFactory());
        this._factories.Add(new DefaultGrpcFactory());
    }
}

type MyProcess struct {
	*cproc.ProcessContainer
}

func NewMyProcess() *MyProcess {
	c := MyProcess{}
	c.ProcessContainer = cproc.NewProcessContainer("mymicroservice", "Sample microservice container")
	c.AddFactory(factory.NewMyComponentFactory())
	c.AddFactory(rbuild.NewDefaultRpcFactory())
	c.AddFactory(rbuild.NewDefaultSwaggerFactory())
	c.AddFactory(gbuild.NewDefaultGrpcFactory())
	return &c
}

import 'package:pip_services3_container/pip_services3_container.dart';
import 'package:pip_services3_grpc/pip_services3_grpc.dart';
import 'package:pip_services3_rpc/pip_services3_rpc.dart';
import 'package:pip_services3_rpc/pip_services3_swagger.dart';

class MyProcess extends ProcessContainer {
  MyProcess() : super('mymicroservice', 'Sample microservice container') {
    factories.add(MyComponentFactory());
    factories.add(DefaultRpcFactory());
    factories.add(DefaultSwaggerFactory());
    factories.add(DefaultGrpcFactory());
  }
}

from pip_services3_container import ProcessContainer
from pip_services3_grpc.build.DefaultGrpcFactory import DefaultGrpcFactory
from pip_services3_rpc.build import DefaultRpcFactory
from pip_services3_swagger.build.DefaultSwaggerFactory import DefaultSwaggerFactory


class MyProcess(ProcessContainer):
    def __init__(self):
        super().__init__("mymicroservice", "Sample microservice container")

        self._factories.add(MyComponentFactory())
        self._factories.add(DefaultRpcFactory())
        self._factories.add(DefaultSwaggerFactory())
        self._factories.add(DefaultGrpcFactory())