重学设计模式 -- 结构型

class Old {
  public request(): string {
    return 'old: the default behavior';
  }
}

class New {
  public request(): string {
    return '.eetpadA eht fo roivaheb laicepS :wen';
  }
}

class Adapter extends Old {
  private adaptee: New;
  constructor(adaptee: New) {
    super();
    this.adaptee = adaptee;
  }
  request(): string {
    const result = this.adaptee.request().split('').reverse().join('');
    return `Adapter: (TRANSLATED) ${result}`;
  }
}

// test
const new1 = new New();
const adaptee = new Adapter(new1);
console.log(adaptee.request()); // Adapter: (TRANSLATED) new: Special behavior of the Adaptee.

/**
 * 颜色接口
 */
interface Color {
  fill(): void;
}

/**
 * 红色实现类
 */
class Red implements Color {
  fill(): void {
    console.log('红色');
  }
}

/**
 * 绿色实现类
 */
class Green implements Color {
  fill(): void {
    console.log('绿色');
  }
}

/**
 * 形状抽象类
 */
abstract class Shape {
  protected color: Color;

  constructor(color: Color) {
    this.color = color;
  }

  abstract draw(): void;
}

/**
 * 圆形实现类
 */
class Circle extends Shape {
  constructor(color: Color) {
    super(color);
  }

  draw(): void {
    console.log('画一个圆形，填充颜色为：');
    this.color.fill();
  }
}

/**
 * 矩形实现类
 */
class Rectangle extends Shape {
  constructor(color: Color) {
    super(color);
  }

  draw(): void {
    console.log('画一个矩形，填充颜色为：');
    this.color.fill();
  }
}

/**
 * 运行示例代码
 */
const red = new Red();
const green = new Green();

const circle = new Circle(red);
circle.draw();

const rectangle = new Rectangle(green);
rectangle.draw();

abstract class Component {
  protected parent: Component | null = null;

  public setParent(parent: Component | null) {
    this.parent = parent;
  }

  public getParent(): Component | null {
    return this.parent;
  }

  public addChild(child: Component): void {}

  public removeChild(child: Component): void {}

  public isComposite(): boolean {
    return false;
  }

  public abstract operation(): string;
}

class Leaf extends Component {
  public operation(): string {
    return 'Leaf';
  }
}

class Composite extends Component {
  protected children: Component[] = [];

  public addChild(child: Component): void {
    this.children.push(child);
    child.setParent(this);
  }

  public removeChild(child: Component): void {
    const index = this.children.indexOf(child);
    this.children.splice(index, 1);
    child.setParent(null);
  }

  public isComposite(): boolean {
    return true;
  }

  public operation(): string {
    const results: string[] = [];
    for (const child of this.children) {
      results.push(child.operation());
    }
    return `Branch(${results.join('+')})`;
  }
}

// test
const simple = new Leaf();
const tree = new Composite();
const branch1 = new Composite();
branch1.addChild(new Leaf());
branch1.addChild(new Leaf());
const branch2 = new Composite();
branch2.addChild(new Leaf());
tree.addChild(branch1);
tree.addChild(branch2);
console.log(tree.operation()) // Branch(Branch(Leaf+Leaf)+Branch(Leaf))

function logger(constructor: Function) {
  console.log(`${constructor?.name} has been invoked.`);
}

function enumerable(value: boolean) {
  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
    descriptor.enumerable = value;
  };
}

function readonly(target: any, propertyKey: string) {
  Object.defineProperty(target, propertyKey, {
    writable: false
  });
}

@logger
class Point {
  constructor(private x: number, private y: number) {}

  @readonly
  @enumerable(false)
  getDistanceFromOrigin() {
    return Math.sqrt(this.x * this.x + this.y * this.y);
  }
}

const point = new Point(3, 4);
console.log(point.getDistanceFromOrigin()); // 输出 5

point.x = 5; // Cannot assign to 'x' because it is a read-only property.

// 子系统 A
class SystemA {
  public operationA(): string {
    return "System A is doing operation A.";
  }
}

// 子系统 B
class SystemB {
  public operationB(): string {
    return "System B is doing operation B.";
  }
}

// 子系统 C
class SystemC {
  public operationC(): string {
    return "System C is doing operation C.";
  }
}

// 外观类
class Facade {
  private systemA: SystemA;
  private systemB: SystemB;
  private systemC: SystemC;

  constructor() {
    this.systemA = new SystemA();
    this.systemB = new SystemB();
    this.systemC = new SystemC();
  }

  // 统一的接口方法，通过调用多个子系统的方法来完成任务
  public executeAllOperations(): string {
    let result = "";

    result += this.systemA.operationA() + "\n";
    result += this.systemB.operationB() + "\n";
    result += this.systemC.operationC() + "\n";

    return result;
  }
}

// 客户端代码
function clientCode() {
  const facade = new Facade();
  console.log(facade.executeAllOperations());
}

clientCode();

interface ISubject {
    request(): void;
}
class RealSubject implements ISubject {
    public request(): void {
        console.log("Real Subject Request");
    }
}

class ProxySubject implements ISubject {
    private subject: RealSubject;
    constructor() {
        this.subject = new RealSubject();
    }

    public request(): void {
        console.log("Proxy Request");
        this.subject.request();
    }
}

// test
const subject: ProxySubject = new ProxySubject();
subject.request();