Proxy

// Subject interface
abstract class Image {
  void display();
}

// Real Subject
class RealImage implements Image {
  final String filename;

  RealImage(this.filename) {
    // Simulate a long loading process
    print('Loading image from $filename...');
    // In a real application, this would actually load the image data.
  }

  @override
  void display() {
    print('Displaying image from $filename.');
  }
}

// Proxy
class ImageProxy implements Image {
  final String filename;
  RealImage? _realImage;

  ImageProxy(this.filename);

  @override
  void display() {
    if (_realImage == null) {
      _realImage = RealImage(filename);
    }
    _realImage!.display();
  }
}

// Client
void main() {
  final imageProxy = ImageProxy('high_resolution_image.jpg');
  imageProxy.display(); // Loads the image on first access
  imageProxy.display(); // Displays from cache
}

trait Image {
  def display(): Unit
}

class RealImage(private val filename: String) extends Image {
  println(s"Loading image from $filename...")
  Thread.sleep(2000) // Simulate a long loading time
  def display(): Unit = println(s"Displaying image from $filename.")
}

class ImageProxy(private val filename: String) extends Image {
  private val realImage: RealImage = new RealImage(filename) // Create the real image only when needed

  def display(): Unit = {
    realImage.display()
  }
}

object ProxyExample {
  def main(args: Array[String]): Unit = {
    val imageProxy = new ImageProxy("high_resolution_image.jpg")
    imageProxy.display() // This will trigger the loading of the RealImage
    imageProxy.display() // Subsequent calls will use the already loaded image
  }
}

<?php

/**
 * Interface for the Subject.  Both RealSubject and ProxySubject implement this.
 */
interface SubjectInterface
{
    public function request();
}

/**
 * The RealSubject class. This is the actual object that does the work.
 */
class RealSubject implements SubjectInterface
{
    private $data;

    public function __construct()
    {
        // Simulate a resource-intensive operation (e.g., database connection)
        echo "RealSubject: Initializing expensive resource...\n";
        sleep(2); // Simulate delay
        $this->data = "Real Data";
    }

    public function request()
    {
        echo "RealSubject: Handling request.\n";
        return $this->data;
    }
}

/**
 * The ProxySubject class.  Controls access to the RealSubject.
 */
class ProxySubject implements SubjectInterface
{
    private $realSubject = null;

    public function request()
    {
        if ($this->realSubject === null) {
            $this->realSubject = new RealSubject();
        }

        return $this->realSubject->request();
    }
}

/**
 * Usage example
 */
$proxy = new ProxySubject();

echo "Client: First request...\n";
$proxy->request();

echo "\nClient: Second request (should be faster)...\n";
$proxy->request();

?>

# frozen_string_literal: true

# Subject (Real Object)
class Book
  def initialize(title, content)
    @title = title
    @content = content
    puts "Loading book: #{@title}" # Simulate loading time
  end

  def read
    @content
  end
end

# Proxy
class BookProxy
  def initialize(title)
    @title = title
    @book = nil
  end

  def read
    @book ||= Book.new(@title, "This is the content of #{@title}.")
    @book.read
  end

  def method_missing(method_name, *args)
    if @book.nil?
      puts "Accessing method '#{method_name}' before book is loaded."
    else
      @book.send(method_name, *args)
    end
  end
end

# Client
proxy = BookProxy.new("The Ruby Way")
puts proxy.read
puts proxy.read # Content is cached, no reloading
# proxy.some_other_method # Demonstrates method_missing

// Define the Subject interface
protocol Subject {
    func request()
}

// The RealSubject class
class RealSubject: Subject {
    func request() {
        print("RealSubject: Handling request.")
    }
}

// The Proxy class
class Proxy: Subject {
    private var realSubject: RealSubject?

    init() {
        // Potentially lazy load the real subject
    }

    private func createRealSubject() {
        realSubject = RealSubject()
    }

    func request() {
        if realSubject == nil {
            createRealSubject()
        }

        // Add some logic here - e.g., check permissions, log access
        print("Proxy: Checking access before firing real request.")
        realSubject?.request()
    }
}

// Client code
let proxy = Proxy()
proxy.request()
proxy.request() // Demonstrates potential lazy loading

// Subject interface
interface Image {
    fun display()
}

// Real Subject
class RealImage(private val filename: String) : Image {
    override fun display() {
        println("Displaying $filename")
    }
}

// Proxy
class ImageProxy(private val filename: String, private val user: String) : Image {
    private var realImage: RealImage? = null

    override fun display() {
        if (user == "admin") {
            if (realImage == null) {
                realImage = RealImage(filename)
            }
            realImage?.display()
        } else {
            println("Access denied for user $user")
        }
    }
}

// Client
fun main() {
    val image1 = ImageProxy("image1.jpg", "admin")
    val image2 = ImageProxy("image2.jpg", "guest")

    image1.display() // Displays image1.jpg
    image2.display() // Access denied
    image1.display() // Displays image1.jpg (already loaded)
}

trait Subject {
    fn do_something(&self);
}

struct RealSubject {
    data: String,
}

impl RealSubject {
    fn new(data: String) {
        println!("RealSubject created with data: {}", data);
    }
}

impl Subject for RealSubject {
    fn do_something(&self) {
        println!("RealSubject doing something with data: {}", self.data);
    }
}

struct Proxy {
    real_subject: Option<Box<dyn Subject>>,
    data: String,
}

impl Proxy {
    fn new(data: String) -> Self {
        Proxy {
            real_subject: None,
            data,
        }
    }

    fn get_real_subject(&mut self) -> &mut Box<dyn Subject> {
        self.real_subject.insert(Box::new(RealSubject::new(self.data.clone())))
    }
}

impl Subject for Proxy {
    fn do_something(&self) {
        let real_subject = self.real_subject.as_ref().unwrap();
        real_subject.do_something();
    }
}

fn main() {
    let proxy = Proxy::new("Important Data".to_string());
    println!("First call to do_something:");
    proxy.do_something();

    println!("Second call to do_something:");
    proxy.do_something();
}

// image.go

// Image is the interface that both RealImage and ProxyImage implement.
type Image interface {
	Display()
}

// RealImage represents the actual image loading and display logic.
type RealImage struct {
	filePath string
}

// NewRealImage creates a new RealImage instance.
func NewRealImage(filePath string) *RealImage {
	return &RealImage{filePath: filePath}
}

// Display loads and displays the image.
func (i *RealImage) Display() {
	println("Loading image from:", i.filePath)
	// Simulate image loading delay
	// time.Sleep(2 * time.Second)
	println("Displaying image.")
}

// ProxyImage is the proxy that controls access to the RealImage.
type ProxyImage struct {
	realImage *RealImage
	filePath  string
}

// NewProxyImage creates a new ProxyImage instance.
func NewProxyImage(filePath string) *ProxyImage {
	return &ProxyImage{filePath: filePath}
}

// Display displays the image, loading it if necessary.
func (p *ProxyImage) Display() {
	if p.realImage == nil {
		p.realImage = NewRealImage(p.filePath)
	}
	p.realImage.Display()
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Interface for the real object (File)
typedef struct File {
  char *filename;
  int data;
  int isOpen;
} File;

File *file_create(const char *filename) {
  File *f = (File *)malloc(sizeof(File));
  if (f) {
    f->filename = strdup(filename);
    f->data = 0;
    f->isOpen = 0;
  }
  return f;
}

void file_open(File *file) {
  printf("Opening file: %s\n", file->filename);
  file->isOpen = 1;
  // Simulate reading data from the file
  file->data = 42;
}

int file_read(File *file) {
  if (file->isOpen) {
    printf("Reading from file: %s\n", file->filename);
    return file->data;
  } else {
    printf("File is not open.\n");
    return -1;
  }
}

void file_close(File *file) {
  printf("Closing file: %s\n", file->filename);
  file->isOpen = 0;
}

void file_destroy(File *file) {
  if (file) {
    free(file->filename);
    free(file);
  }
}

// Proxy interface
typedef struct FileProxy {
  File *realFile;
  char *filename;
} FileProxy;

FileProxy *file_proxy_create(const char *filename) {
  FileProxy *proxy = (FileProxy *)malloc(sizeof(FileProxy));
  if (proxy) {
    proxy->realFile = NULL;
    proxy->filename = strdup(filename);
  }
  return proxy;
}

void file_proxy_open(FileProxy *proxy) {
  if (proxy->realFile == NULL) {
    proxy->realFile = file_create(proxy->filename);
    file_open(proxy->realFile);
  } else {
    printf("File already open.\n");
  }
}

int file_proxy_read(FileProxy *proxy) {
  if (proxy->realFile == NULL) {
    printf("File not opened yet.\n");
    return -1;
  }
  return file_read(proxy->realFile);
}

void file_proxy_close(FileProxy *proxy) {
  if (proxy->realFile != NULL) {
    file_close(proxy->realFile);
    file_destroy(proxy->realFile);
    proxy->realFile = NULL;
  }
}

void file_proxy_destroy(FileProxy *proxy) {
  if (proxy) {
    free(proxy->filename);
    free(proxy);
  }
}

int main() {
  FileProxy *proxy = file_proxy_create("my_file.txt");

  file_proxy_read(proxy); // File not opened yet.

  file_proxy_open(proxy);
  int data = file_proxy_read(proxy);
  printf("Data read: %d\n", data);

  file_proxy_open(proxy); // File already open.

  file_proxy_close(proxy);
  file_proxy_read(proxy); // File not opened yet.

  file_proxy_destroy(proxy);

  return 0;
}

#include <iostream>
#include <memory>
#include <string>

// Forward declaration
class RealSubject;

// Subject interface
class Subject {
public:
    virtual ~Subject() = default;
    virtual void request() = 0;
};

// RealSubject
class RealSubject : public std::enable_shared_from_this<RealSubject> {
public:
    void request() {
        std::cout << "RealSubject: Handling request." << std::endl;
    }
};

// Proxy
class Proxy : public Subject {
public:
    Proxy(std::shared_ptr<RealSubject> realSubject) : realSubject_(realSubject) {}

    void request() override {
        std::cout << "Proxy: Logging the request before forwarding." << std::endl;
        // Add access control or other logic here if needed
        if (realSubject_) {
            realSubject_->request();
        } else {
            std::cout << "Proxy: RealSubject is unavailable." << std::endl;
        }
    }

private:
    std::shared_ptr<RealSubject> realSubject_;
};

// Client code
int main() {
    auto realSubject = std::make_shared<RealSubject>();
    auto proxy = std::make_shared<Proxy>(realSubject);

    proxy->request();

    // Simulate RealSubject becoming unavailable
    realSubject.reset();
    proxy->request();

    return 0;
}

// Define the common interface for the real object and the proxy
public interface ISubject
{
    void Request();
}

// The real object
public class RealSubject : ISubject
{
    public void Request()
    {
        Console.WriteLine("RealSubject: Handling request.");
    }
}

// The proxy
public class Proxy : ISubject
{
    private ISubject? _realSubject;

    public void Request()
    {
        if (_realSubject == null)
        {
            Console.WriteLine("Proxy: Initializing RealSubject.");
            _realSubject = new RealSubject();
        }

        Console.WriteLine("Proxy: Logging request before forwarding.");
        _realSubject.Request();
        Console.WriteLine("Proxy: Logging request after forwarding.");
    }
}

// Client code
public class Client
{
    public static void Main(string[] args)
    {
        Proxy proxy = new Proxy();
        proxy.Request();
        proxy.Request(); // Demonstrates lazy initialization
    }
}

// Define the interface for the real object
interface RemoteData {
  data: string;
  sensitiveData: string;
}

// The real object
const realData: RemoteData = {
  data: "Public information",
  sensitiveData: "Confidential information",
};

// Define the handler for the proxy
const handler: ProxyHandler<RemoteData> = {
  get: (target, prop, receiver) => {
    const userRole = "admin"; // Simulate user role

    if (prop === "sensitiveData" && userRole !== "admin") {
      return "Access denied";
    }

    return Reflect.get(target, prop, receiver);
  },
};

// Create the proxy
const secureData = new Proxy(realData, handler);

// Usage
console.log(secureData.data); // Output: Public information
console.log(secureData.sensitiveData); // Output: Confidential information (if user is admin) or Access denied

// Subject (Real Object)
class Subject {
  doSomething() {
    console.log("Subject: Doing something.");
  }

  doAnotherThing() {
    console.log("Subject: Doing another thing.");
  }
}

// Proxy
class Proxy {
  constructor(subject) {
    this.subject = subject;
  }

  get(target, prop, receiver) {
    console.log(`Proxy: Accessing property "${prop}".`);
    return Reflect.get(target, prop, receiver);
  }

  apply(target, thisArg, argumentsList) {
    console.log("Proxy: Calling method.");
    return target.apply(thisArg, argumentsList);
  }
}

// Usage
const subject = new Subject();
const proxy = new Proxy(subject, {
  get: new Proxy().get,
  apply: new Proxy().apply
});

proxy.doSomething();
proxy.doAnotherThing();

class RealSubject:
    def request(self):
        print("RealSubject: Handling request.")

class Proxy:
    def __init__(self, real_subject):
        self.real_subject = real_subject

    def request(self):
        print("Proxy: Logging before request.")
        self.real_subject.request()
        print("Proxy: Logging after request.")

def client_code(subject):
    subject.request()

if __name__ == "__main__":
    real_subject = RealSubject()
    proxy = Proxy(real_subject)

    print("Client: I'm not aware of the RealSubject.")
    client_code(proxy)

// Subject interface
interface Subject {
    String operation(String data);
}

// Real Subject
class RealSubject implements Subject {
    @Override
    public String operation(String data) {
        System.out.println("RealSubject: Handling request.");
        return "RealSubject: Result for " + data;
    }
}

// Proxy Subject
class ProxySubject implements Subject {
    private RealSubject realSubject;
    private boolean isCreated = false;

    @Override
    public String operation(String data) {
        if (!isCreated) {
            System.out.println("ProxySubject: Creating RealSubject.");
            realSubject = new RealSubject();
            isCreated = true;
        }

        System.out.println("ProxySubject: Logging request: " + data);
        String result = realSubject.operation(data);
        System.out.println("ProxySubject: Logging response: " + result);
        return result;
    }
}

// Client
public class ProxyExample {
    public static void main(String[] args) {
        Subject proxy = new ProxySubject();
        proxy.operation("Hello");
        proxy.operation("World");
    }
}