WikiSort.ru - Не сортированное

using System;
using System.Collections;
 
namespace DoFactory.GangOfFour.Interpreter.Structural
{
  /// <summary>
  /// MainApp startup class for Structural
  /// Interpreter Design Pattern.
  /// </summary>
  class MainApp
  {
    /// <summary>
    /// Entry point into console application.
    /// </summary>
    static void Main()
    {
      Context context = new Context();
 
      // Usually a tree
      ArrayList list = new ArrayList();
 
      // Populate 'abstract syntax tree'
      list.Add(new TerminalExpression());
      list.Add(new NonterminalExpression());
      list.Add(new TerminalExpression());
      list.Add(new TerminalExpression());
 
      // Interpret
      foreach (AbstractExpression exp in list)
      {
        exp.Interpret(context);
      }
 
      // Wait for user
      Console.ReadKey();
    }
  }
 
  /// <summary>
  /// The 'Context' class
  /// </summary>
  class Context
  {
  }
 
  /// <summary>
  /// The 'AbstractExpression' abstract class
  /// </summary>
  abstract class AbstractExpression
  {
    public abstract void Interpret(Context context);
  }
 
  /// <summary>
  /// The 'TerminalExpression' class
  /// </summary>
  class TerminalExpression : AbstractExpression
  {
    public override void Interpret(Context context)
    {
      Console.WriteLine("Called Terminal.Interpret()");
    }
  }
 
  /// <summary>
  /// The 'NonterminalExpression' class
  /// </summary>
  class NonterminalExpression : AbstractExpression
  {
    public override void Interpret(Context context)
    {
      Console.WriteLine("Called Nonterminal.Interpret()");
    }
  }
}

/* Output
Called Terminal.Interpret()
Called Nonterminal.Interpret()
Called Terminal.Interpret()
Called Terminal.Interpret()
*/

__doc__  = '''
	Система для вычисления и манипулирования булевыми выражениями. Пример из книги 
	Gang of Four - "Design Patterns: Elements of Reusable Object-Oriented Software"
	'''

from abc import ABCMeta, abstractmethod


class Context:
	"""
	Контекст среды исполнения интерпретатора
	"""

	def __init__(self, variables: dict = {}) -> None:
		"""
		Constructor.

		:param variables: словарь соответствий имен переменных их значениям
		"""
		self._variables = variables

	class ContextException(Exception):
		"""
		Исключение, прокидываемое в случае некорректной работы с данным классом
		"""
		pass

	def lookup(self, name: str) -> bool:
		"""
		Получает значение переменной по ее имени

		:param name: имя переменной
		"""
		if name in self._variables:
			return self._variables[name]
		raise self.ContextException('Неизвестная переменная {}'.format(name))

	def assign(self, name: str, value: bool) -> None:
		"""
		Назначает значение переменной по ее имени

		:param name: имя переменной
		:param value: значение переменной
		"""
		self._variables[name] = value


class BooleanExp(metaclass=ABCMeta):
	"""
	Абстрактное логическое выражение
	"""

	@abstractmethod
	def evaluate(self, context: Context) -> bool:
		"""
		Получение результата логического выражения
		"""
		pass


class ConstantExp(BooleanExp):
	"""
	Логическая константа
	"""

	def __init__(self, value: bool):
		"""
		Constructor.

		:param value: значение выражения (True или False)
		"""
		self._value = value

	def evaluate(self, context: Context):
		return self._value


class VariableExp(BooleanExp):
	"""
	Логическая переменная (значение переменных хранится в объекте контекста интерпретатора)
	"""

	def __init__(self, name: str) -> None:
		"""
		Constructor.

		:param name: название переменной
		"""
		self._name = name

	def evaluate(self, context: Context) -> bool:
		return context.lookup(self._name)


class BinaryOperationExp(BooleanExp, metaclass=ABCMeta):
	"""
	Абстрактный класс для бинарных логических операций
	"""

	def __init__(self, left: BooleanExp, right: BooleanExp) -> None:
		"""
		Constructor.

		:param left: левый операнд
		:param right: правый операнд
		"""
		self._left = left
		self._right = right


class AndExp(BinaryOperationExp):
	"""
	Конъюнкция
	"""

	def evaluate(self, context: Context) -> bool:
		return self._left.evaluate(context) and self._right.evaluate(context)


class OrExp(BinaryOperationExp):
	"""
	Дизъюнкция
	"""

	def evaluate(self, context: Context) -> bool:
		return self._left.evaluate(context) or self._right.evaluate(context)


class NotExp(BooleanExp):
	"""
	Отрицание
	"""

	def __init__(self, operand: BooleanExp) -> None:
		"""
		Constructor.

		:param operand: операнд, к которому применяется операция
		"""
		self._operand = operand

	def evaluate(self, context: Context) -> bool:
		return not self._operand.evaluate(context)


def execute_test(context: Context, x: bool, y: bool) -> None:
	"""
	Функция для выполнения тестирования нашего интерпретатора
	"""
	context.assign('x', x)
	context.assign('y', y)
	expression = OrExp(		# (True and x) or (у and (not x))
		AndExp(ConstantExp(True), VariableExp('x')), 
		AndExp(VariableExp('y'), NotExp(VariableExp('x')))
	)
	print(expression.evaluate(context))


if __name__ == '__main__':
	print('OUTPUT:')
	context = Context()
	execute_test(context, True, False)
	execute_test(context, False, True)
	execute_test(context, False, False)

'''
OUTPUT:
True
True
False
'''

<?php
/**
 * Пример шаблона Interpreter с использованием композиции
 */
abstract class Expression {

  private static $_count = 0;
  private $_key = null;
  
  public abstract function interpret( InterpreterContext $context ); 

  public function getKey()  {
    if( !isset( $this->_key ) ) {
      self::$_count++;
      $this->_key = self::$_count;
    }
    return $this->_key;
  }

}

class LiteralExpression extends Expression  {

  private $_value = null;
  
  public function __construct( $value ) {
    $this->_value = $value;
  }
  
  public function interpret( InterpreterContext $context ) {
    $context->replace( $this, $this->_value ); 
  }

}

class VariableExpression extends Expression {

  private $_name = null;
  private $_val = null;
  
  public function __construct( $name, $val = null ) {
    $this->_name = $name;
    $this->_val = $val; 
  }
  
  public function interpret( InterpreterContext $context ) {
    if( !is_null( $this->_val ) )
      $context->replace( $this, $this->_val );
  }
  
  public function setValue( $value )  {
    $this->_val = $value;
  }
  
  public function getKey()  {
    return $this->_name;
  }

}

abstract class OperatorExpression extends Expression {

  protected $leftoperand = null;
  protected $rightoperand = null;
  
  public function __construct( Expression $leftoperand, Expression $rightoperand )  {
    $this->leftoperand = $leftoperand;
    $this->rightoperand = $rightoperand;
  }
  
  public function interpret( InterpreterContext $context ) {
    $this->leftoperand->interpret( $context );
    $this->rightoperand->interpret( $context );
    $resultleft = $context->lookup( $this->leftoperand );
    $resultright = $context->lookup( $this->rightoperand );
    $this->doInterpret( $context, $resultleft, $resultright );
  }
  
  protected abstract function doInterpret( InterpreterContext $context, $resultleft, $resultright );

}

class EqualsExpression extends OperatorExpression {

  protected function doInterpret( InterpreterContext $context, $resultleft, $resultright )  {
    $context->replace( $this, $resultleft == $resultright );
  }

}

class BooleanOrExpression extends OperatorExpression {

  protected function doInterpret( InterpreterContext $context, $resultleft, $resultright )  {
    $context->replace( $this, $resultleft || $resultright );    
  }

}

class BooleanAndExpression extends OperatorExpression {

  protected function doInterpret( InterpreterContext $context, $resultleft, $resultright )  {
    $context->replace( $this, $resultleft && $resultright );    
  }

}

class InterpreterContext {

  private $_expressionstore = array();
  
  public function replace( Expression $exp, $value ) {
    $this->_expressionstore[$exp->getKey()] = $value;
  }
  
  public function lookup( Expression $exp )  {
    return $this->_expressionstore[$exp->getKey()];
  } 

}

$context = new InterpreterContext();
$input = new VariableExpression( 'input' );
$statement = new BooleanOrExpression(
  new EqualsExpression( $input, new LiteralExpression( "четыре" ) ),
  new EqualsExpression( $input, new LiteralExpression( "4" ) )
);

foreach( array( "четыре", "4", "52" ) as $value ) {
  $input->setValue( $value );
  print "{$value}:<br>";
  $statement->interpret( $context );
  print $context->lookup( $statement )
  ? "Соответствует<br><br>"
  : "Не соответствует<br><br>";
}
?>