FilesExpand file tree

 master

/

prototype.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

82 lines (61 loc) · 2.43 KB

 master

/

prototype.py

Copy path

Top

File metadata and controls

• Code
• Blame

82 lines (61 loc) · 2.43 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

"""

*What is this pattern about?

This patterns aims to reduce the number of classes required by an

application. Instead of relying on subclasses it creates objects by

copying a prototypical instance at run-time.

This is useful as it makes it easier to derive new kinds of objects,

when instances of the class have only a few different combinations of

state, and when instantiation is expensive.

*What does this example do?

When the number of prototypes in an application can vary, it can be

useful to keep a Dispatcher (aka, Registry or Manager). This allows

clients to query the Dispatcher for a prototype before cloning a new

instance.

Below provides an example of such Dispatcher, which contains three

copies of the prototype: 'default', 'objecta' and 'objectb'.

*TL;DR

Creates new object instances by cloning prototype.

"""

from __future__ import annotations

from typing import Any

class Prototype:

def __init__(self, value: str = "default", **attrs: Any) -> None:

self.value = value

self.__dict__.update(attrs)

def clone(self, **attrs: Any) -> Prototype:

"""Clone a prototype and update inner attributes dictionary"""

# Python in Practice, Mark Summerfield

# copy.deepcopy can be used instead of next line.

obj = self.__class__(**self.__dict__)

obj.__dict__.update(attrs)

return obj

class PrototypeDispatcher:

def __init__(self):

self._objects = {}

def get_objects(self) -> dict[str, Prototype]:

"""Get all objects"""

return self._objects

def register_object(self, name: str, obj: Prototype) -> None:

"""Register an object"""

self._objects[name] = obj

def unregister_object(self, name: str) -> None:

"""Unregister an object"""

del self._objects[name]

def main() -> None:

"""

>>> dispatcher = PrototypeDispatcher()

>>> prototype = Prototype()

>>> d = prototype.clone()

>>> a = prototype.clone(value='a-value', category='a')

>>> b = a.clone(value='b-value', is_checked=True)

>>> dispatcher.register_object('objecta', a)

>>> dispatcher.register_object('objectb', b)

>>> dispatcher.register_object('default', d)

>>> [{n: p.value} for n, p in dispatcher.get_objects().items()]

[{'objecta': 'a-value'}, {'objectb': 'b-value'}, {'default': 'default'}]

>>> print(b.category, b.is_checked)

a True

"""

if __name__ == "__main__":

import doctest

doctest.testmod()