How to use the angular2/core.Injectable function in angular2

public state: any,
    public title: string,
    public url: string
  ) {}
}

// TODO(gdi2290): toJSON
class PopStateEvent {
  public type = 'popstate';

  constructor(
    public state: any
  ) {}
}

@Injectable()
export class NodePlatformLocation extends PlatformLocation {
  private _loc: LocationConfig;
  private _stack: Array = [];
  private _stackIndex = -1;
  private _popStateListeners: Array = [];
  private _baseHref: string = '/';

  constructor(
    @Inject(REQUEST_URL) requestUrl: string,
    @Optional() @Inject(APP_BASE_HREF) baseUrl?: string) {
    super();
    this._baseHref = baseUrl || '/';
    this.pushState(null, null, joinWithSlash(this._baseHref, requestUrl));
  }

  get search(): string { return this._loc.search; }

import {Injectable} from 'angular2/core';
import {Ingredient} from "./ingredient";
import {SHOPPING_LIST} from "../mock/shopping-list";

@Injectable()
export class ShoppingListService {
	getAllItems() {
		return SHOPPING_LIST;
	}

	getItem(index: number) {
		return SHOPPING_LIST[index];
	}

	getIndexOfItem(item: Ingredient) {
		console.log("getIndexOfItem:", item);
		console.log("SHOPPING_LIST:", SHOPPING_LIST);
		console.log("SHOPPING_LIST.indexOf(item):", SHOPPING_LIST.indexOf(item));		
		return SHOPPING_LIST.indexOf(item);
	}

import {Component, enableProdMode, Injectable} from 'angular2/core';
import {Http, Headers, HTTP_PROVIDERS} from 'angular2/http';
import 'rxjs/add/operator/map';



@Injectable()
export class ChartDataService {
    constructor(private http: Http) {}
    request(url:String) {
        return this.http
            .get(url)
            .map(res => res.json());


    }
}

this.href = parsed.href;
    this.pathname = parsed.pathname;
    this.port = parsed.port;
    this.protocol = parsed.protocol;
    this.search = parsed.search;
    this.origin = parsed.protocol + '//' + parsed.hostname + ':' + parsed.port;
  }
  reload(forcedReload?: boolean): void {/*TODO*/}
  replace(url: string): void {
    this.assign(url);
  }
  toString(): string { /*TODO*/ return ''; }
}


@Injectable()
export class ServerLocationStrategy extends LocationStrategy {
  private _location: Location = new MockServerLocation();
  private _history:  History = new MockServerHistory();
  private _baseHref: string = '/';

  constructor(
    @Optional() @Inject(BASE_URL) url?: string,
    @Optional() @Inject(APP_BASE_HREF) baseUrl?: string) {
    super();
    this._baseHref = baseUrl;
    this._location.assign(url || '/');
  }

  onPopState(fn: EventListener): void {/*TODO*/}

  getBaseHref(): string { return this._baseHref; }

import {EventEmitter, Injectable} from 'angular2/core';
import {Observable, Observer} from 'rxjs/Rx';

import {HttpService} from '../utils/http.service';

@Injectable()
export class DSpaceService {

    private REST: string;

    private url: String;

    private listing: Observer;
    
    private store: { directory: Object[] };

    directory: Observable;

    emitter: EventEmitter;

    constructor(private httpService: HttpService) {
        this.REST = '/tdl-rest';

import {Injectable, EventEmitter} from 'angular2/core';
import {Observable} from 'rxjs/Rx';

import {$WebSocket} from 'angular2-websocket/angular2-websocket'

@Injectable()
export class WebSocketService {

    webSocket: WebSocket;

    pending: Array;

    emitter: EventEmitter;

    resolveMap: Map;

    isReady: boolean;

    constructor() {

        this.webSocket = new WebSocket("ws://localhost:3001");

options: Object,
    parentWindowId: number,
    isInline: boolean,
    parameters: Object,
    inFront: boolean
}

export interface WindowList {
    [windowId: number]: WindowInfo
}

export interface JarvesWindowList {
    [windowId: number]: JarvesWindow
}

@Injectable()
export default class WindowManagement {

    public activeWindowList:WindowList = {};
    public activeWindowId = -1;
    public currentWindowIndex = 0;
    public activeWindow:JarvesWindow = null;
    public jarvesWindows:JarvesWindowList = {};

    constructor(protected jarves:Jarves) {
        this.activeWindowList = {};
        this.activeWindowId = -1;
        this.currentWindowIndex = 0;
    }

    protected updateUrlHashActive:boolean = false;

import {
    Directive,
    DynamicComponentLoader,
    ElementRef,
    ComponentRef,
    Renderer,
    Injectable,
    Injector,
    provide} from 'angular2/core';


import {TypeaheadResultContainer} from './typeaheadResultContainer';

@Injectable()
@Directive({
    selector: '[typeahead]',
    host: {
        '(keyup)': 'onKeyup($event)'
    },
    properties: [
        'data:typeahead'
    ]
})
export class Typeahead {
    public results;
    private data:any;
    private resultElement: Promise;
    private resultInstance: TypeaheadResultContainer;

    constructor(private componentLoader: DynamicComponentLoader,

import {Injectable} from 'angular2/core';

import {ToolbarOption} from '../../controls';
import {EntityCreatorTool, BaseTool, EntityMoveTool} from '../tools';

/**
 * Provide access to tools for the canvas.
 * @return {[type]} [description]
 */
@Injectable()
export class ToolService {
    private _tools : {[key:string]:BaseTool} = {};
    private _default : BaseTool;

    constructor(entityCreator : EntityCreatorTool,
                entityMoveTool : EntityMoveTool) {
        this._default = entityMoveTool;
        this.addTool(entityCreator);
        this.addTool(entityMoveTool);
    }

    /**
     * The default tool.
     */
    get defaultTool() : BaseTool {
        return this._default;

//-------------------------------------------------------------------
const BASE_URL = 'http://localhost:3000/items/';
const HEADER = { headers: new Headers({ 'Content-Type': 'application/json'})};

export interface Item{
  id: number;
  name: string;
  description: string;
}

export interface AppStore {
  items: Item[],
  selectedItem: Item
}

@Injectable()
export class ItemsService {
  items: Observable>;

  constructor(private http: Http, private store: Store){
    this.items = store.select('items');
  }

  loadItems() {
    this.http.get(BASE_URL)
      .map(res => res.json())
      .map(payload => ({type: 'ADD_ITEMS', payload}))
      .subscribe(action => this.store.dispatch(action));
  }

  saveItem(item: Item) {
    (item.id) ? this.updateItem(item) : this.createItem(item);