-

具有copy on write, 且擁有比C++更靈活的reference機制 +

A little class use for packing the data part of another class. With this technique, it can achieve Copy-On-Write(COR) mechanism at background and have a reference mechanism which much more flexible then the one C++ has. More...

#include "Self.h"

@@ -74,103 +74,143 @@ Public Types enum DuplicateType { COPY_FROM, REFERENCE_FROM } - 複製資料的方法 More...
+ Kind of ways of duplicating. More...
- + - + - - - + + + - + - + - + - + - + - + - + - + - + - + - +

Public Member Functions
	Self ()
	constructor, 並宣告一個實體 More...
	constructor with a real entity More...

	Self (Data const &d)
	connstructor, 宣告一個實體, 其中該實體的constructor用copy constructor More...
	connstructor with a real entity with it using its copy constructor More...

	Self (Self const &b, DuplicateType d=COPY_FROM)
	constructor, 使用給定的Self當作init value, 並且可以指定要用 reference還是copy More...

	Self (Self const &b, DuplicateType d)
	constructor with given another Self More...

	Self (Self const &b)
	Disallow copy constructor. More...

	~Self ()
	解構子 More...
	destructor More...

Data const *	operator-> () const
	回傳指向 Data const 的指標 More...
	Return the constant pointer to the data. More...

Data *	operator-> ()
	回傳指向 Data 的指標, 如有需要, 這邊會做資料的duplicate More...
	Return the non-constant pointer to the data (COR's clone might occure here. More...

Self &	operator() () const
	回傳非const型態的自己 More...
	Return the non-constant reference of `*this`. More...

Self const &	copyFrom (Self const &s)
	將給定的 `Self` 的資料複製到自己這裡 More...
	Copy the gived `Self` to myself. More...

Self const &	referenceFrom (Self const &s)
	將自己reference 到給定的 `Self` More...
	Reference myself from given `Self` object. More...

Self const &	duplicateFrom (Self const &s, DuplicateType t)
	依據給定DuplicateType選擇要呼叫copyFrom還是referenceFrom More...
	call `copyFrom()` or `referenceFrom()` depend on your instruction More...

bool	same (Self const &s) const
	比對兩個 `Self` 是否指向同一個reference More...
	Compare tht if the gived `Self` object is reference from the same object of me. More...

bool	equal (Self const &s) const
	比對兩個 `Self` 的內容是否一樣 More...
	Compare that the data are the same. More...

bool	referenceLess (Self const &s) const
	以reference作為判斷依據的小於判斷 More...
	Order compare by reference pointer. More...

void	operator= (Self const &a)
	將 `operator=` 給disable掉 More...
	Disallow default `'operator='`. More...

Detailed Description

template<class Data>
class meow::Self< Data >

-

具有copy on write, 且擁有比C++更靈活的reference機制

-

使用上就是把所有成員變數包到一個class/structure裡, 送給Self
- 例如以下

+

A little class use for packing the data part of another class. With this technique, it can achieve Copy-On-Write(COR) mechanism at background and have a reference mechanism which much more flexible then the one C++ has.

+

Sample code:

class A {
private:
  struct Myself {
    int data;

-    Myself() {                               // 必要

+

+    Myself() {                               // Necessary
      data = 0;
    }

-    Myself(Myself const& b): data(b.data) {  // 必要, copy constructor

+

+    Myself(Myself const& b): data(b.data) {  // Necessary, copy constructor
    }

+
    ~Myself() {
    }

-    bool operator==(Myself const& b) const { // 不一定需要(有用到equal()才要)

+

+    bool operator==(Myself const& b) const { // Optional (this method will

+                                             // be called only if you use

+                                             // Self::equal() method)
      return (data == b.data);
    }
  };

-  Self<Myself> const self;

+  Self<Myself> const self;          // Here we use 'constant' data type in 

+                                    // order to have a coutious coding style

+                                    // and allow the COR mechanism to clone

+                                    // data only when we really want to

+                                    // modify them.
public:

-  A(): self() { }                                // 預設呼叫Myself()

-  A(A const& a): self(a.self, COPY_FROM) { }     // 用Myself(b)做到copyFrom

+  A(): self() { }                            // Default constructor

+

+  A(A const& a): self(a.self, COPY_FROM) { } // Copy constructor. You must

+                                             // tell me which way of

+                                             // duplicating should I use.

+                                             // It strongly recommended you

+                                             // use COYP_FROM for keeping the

+                                             // C++'s original behavior.
  ~A() { }

-  void setMemeber(int k) {

-    self()->data = k;  // self()->?? 可以有write權限

-  }

+
  int getMemember(int wh) const {

-    return self->data; // self->?? 只有const

+    return self->data;   // Use 'operator->()' to get the pointer of the data

+                         // The pointer is constant or not will depend on

+                         // whether the left side variable of '->' is

+                         // constant or not.

+                         // If we just want to read the data, use

+                         // 'self' instead of 'self()'
  }

-  A referenceFrom(A const& a) {

-    self.referenceFrom(a.self);

+  void setMemeber(int k) {

+    self()->data = k;    // As a result of 'self()' returning a non-constant

+                         // reference of itself, here we get the permission

+                         // for modiying data.

+                         // So now we can observe that if you type

+                         // 'Self<Myself> self' instead of the one above,

+                         // 'self' and 'self()' will become the same one and

+                         // both of them allow you using '->' for getting

+                         // writing permission. At the same time, the COR

+                         // machanism will become useless because everytime

+                         // you want to access the date, Self will copy the

+                         // data to prevent you to modify it no matter that

+                         // you might just want to read it.
  }

-  A copyFrom(A const& a) {

-    self.copyFrom(a.self);

+

+  A referenceFrom(A const& a) {

+    self.referenceFrom(a.self);
  }

-  A& operator=(A const& b) { // for std::swap

-    copyFrom(b);

+

+  A copyFrom(A const& a) {

+    self.copyFrom(a.self);

+  }

+

+  A& operator=(A const& b) { // If you really like to use operator=, it

+                             // strongly recommended you use 'copyFrom()' for

+                             // keeping C++'s original behavior.

+    copyFrom(b);
  }
};

-

Author: cathook

-

Warning: Self 這個class會把operator= 給disable掉, 所以使用它當 kernel的class預設的 operator= 都會無法使用

+

Note that 'referenceFrom()' will cause the two object become the same one, Which means that if you do something like 'a.referenceFrom(b); a.copyFrom(c); ', the result is that the value of a,b,c will all the same one.

+

Author: cathook

+

Warning: This class disabled the method operator= and copy constructor in order to prevent upexplicit default behavior, so if you want to have one of them (or both), you must implement yourself

+ +

Definition at line 104 of file Self.h.

Enumerator
COPY_FROM	- 跟一般的複製一樣 +
Enumerator
COPY_FROM	+ Normal copy operation.
REFERENCE_FROM	- 參照, 執行完兩個Self會完全等效 +
REFERENCE_FROM	+ By reference, much like pointer's copy operation.

[in]	d	Inital data
		DuplicateType	d = `COPY_FROM`	d

[in]	b	給定的Self
[in]	d	指定要用copy還是reference
[in]	b	Another Self object.
[in]	d	To indicate type of way of duplicating

[in]	s	給定的`Self`
[in]	s	gived `Self`

[in]	s	給定的 `Self`
[in]	t	給定的 `DuplicateType`
[in]	s	gived `Self` object
[in]	t	instruction

Public Member Functions

Detailed Description

template<class Data>
class meow::Self< Data >

Member Enumeration Documentation

Constructor & Destructor Documentation

Public Member Functions

Detailed Description

template<class Data> class meow::Self< Data >

Member Enumeration Documentation

Constructor & Destructor Documentation

template<class Data>
class meow::Self< Data >