Papper\Papper

Complexity

Total Complexity

11

Size/Duplication

Total Lines	93
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	12
Bugs	2	Features	3

10 Methods

Rating	Name	Duplication	Size	Complexity
A	createMap()	0	4	1
A	configureMapping()	0	4	1
A	map()	0	4	1
A	mappingOptions()	0	4	1
A	validate()	0	4	1
A	reset()	0	4	1
A	engine()	0	5	2
A	__construct()	0	3	1
A	__clone()	0	3	1
A	__wakeup()	0	3	1

<?php

namespace Papper;

use Papper\FluentSyntax\ExecuteMappingFluentSyntax;
use Papper\FluentSyntax\MappingFluentSyntax;

/**
 * Main entry point for Papper, for both creating maps and performing maps.
 * Static proxy to Engine.
 *
 * @author Vladimir Komissarov <dr0id@dr0id.ru>
 */
class Papper

Since you have declared the constructor as private, maybe you should also declare the class as final.

{
	/**
	 * Creates a TypeMap for the source's type and destination's type.
	 *
	 * @param string $sourceType Source type
	 * @param string $destinationType Destination type
	 * @return MappingFluentSyntax
	 */
	public static function createMap($sourceType, $destinationType)
	{
		return self::engine()->createMap($sourceType, $destinationType);
	}

	/**
	 * Configure mapping
	 *
	 * @param MappingConfigurationInterface $configuration
	 */
	public static function configureMapping(MappingConfigurationInterface $configuration)
	{
		self::engine()->configureMapping($configuration);
	}

	/**
	 * Initialize a mapping from the source object.
	 * The source type can be is inferred from the source object.
	 *
	 * @param object|object[] $source Source object or collection to map from
	 * @param string|null $sourceType Source object type
	 * @throws MappingException
	 * @return ExecuteMappingFluentSyntax
	 */
	public static function map($source, $sourceType = null)
	{
		return self::engine()->map($source, $sourceType);
	}

	/**
	 * Returns mapping options
	 *
	 * @return MappingOptionsInterface
	 */
	public static function mappingOptions()
	{
		return self::engine()->getMappingOptions();
	}

	/**
	 * Validates that every top level destination property is mapped to source property.
	 * If not, a ValidationException is thrown detailing any missing mappings.
	 *
	 * @throws ValidationException if any TypeMaps contain unmapped properties
	 */
	public static function validate()
	{
		self::engine()->validate();
	}

	/**
	 * Clear out all existing configuration
	 */
	public static function reset()
	{
		self::engine()->reset();
	}

	/**
	 * Returns engine singleton instance
	 *
	 * @return Engine
	 */
	public static function engine()
	{
		static $instance;
		return $instance ?: $instance = new Engine();
	}

	//<editor-fold desc="Singleton/Static">
	private function __construct()
	{
	}

	private function __clone()
	{
	}

	/** @noinspection PhpUnusedPrivateMethodInspection */
	private function __wakeup()
	{
	}
	//</editor-fold>
}