name: Wrapper<class TObject>

synopsis:

g++ [flags ...] file ...

#include <Wrapper.h>

Wrapper();
boolean assign(const Wrapper<TObject>& arg);
boolean assign(const TObject& arg);

quick start:

// declare a character wrapper and insert a character in it
//
Wrapper<Char> wrapper0;
Char item(L'a');
wrapper0.assign(&item);

// use the copy constructor to create a second wrapper
//
Wrapper<Char> wrapper1(wrapper0);

// get the items out of each of the wrappers
//
Char* char1 = wrapper0.getItem();
Char* char2 = wrapper1.getItem();

// test the characters for equality
//
if (!char1->eq(*char2)) {
   // error
}

description:

The Wrapper class can be used to provide a minimal implementation of the IFC required public methods for some existing class that does not conform to the IFC standards. Through this class, any object can be placed in an IFC data structure. Its main use is to allow technology to be imported into the IFC environment, such as classes from the Standard Template Library (STL), and augmented with the IFC required methods. The benefit of this is that useful IFC mechanisms, such as I/O, are now available to users. Similarly, other template classes can be used on this augmented class.

dependencies:

String

public constants:

define the class name:

static const SysString CLASS_NAME = L"Wrapper";

i/o related constants:

static const SysString DEF_PARAM = L"item";

error codes:

general Wrapper class error:
```
static const long ERR = 42100;
```
error code indicating the method is not defined in the wrapper:
```
static const long ERR_NOTDEF = 42101;
```

protected data:

debugging parameter:
```
static Integral::DEBUG debug_level_d;
```
static memory manager:
```
static MemoryManager mgr_d;
```

required public methods:

static methods: diagnose method is moved outside the class header file and defined in the WrapperDiagnose.h in order to avoid issues with preprocessing of the diagnose code
```
static const String& name();
```
```
static boolean diagnose(Integral::DEBUG debug_level);
```

debug methods:

boolean debug(const unichar* message) const;

static boolean setDebug(Integral::DEBUG debug_level);

destructor/constructor(s):

~Wrapper();

Wrapper();

Wrapper(const Wrapper<TObject>& copy_wrapper);

assign methods:

boolean assign(const Wrapper<TObject>& copy_wrapper);

operator= methods:

Wrapper<TObject>& operator=(const Wrapper<TObject>& arg);

i/o methods: refer to the notes section for an explanation of why there are two read and write methods in this class

long sofSize() const;

boolean read(Sof& sof, long tag);

boolean read(Sof& sof, long tag, const String& name);

boolean write(Sof& sof, long tag) const;

boolean write(Sof& sof, long tag, const String& name) const;

boolean readData(Sof& sof, const String& pname = DEF_PARAM,long size = SofParser::FULL_OBJECT, boolean param = true, boolean nested = false);

boolean writeData(Sof& sof, const String& pname = DEF_PARAM) const;

equality methods:

boolean eq(const Wrapper<TObject>& compare_wrapper) const;

memory management methods

static void* operator new(size_t size);

static void* operator new[](size_t size);

static void operator delete(void* ptr);

static void operator delete[](void* ptr);

static boolean setGrowSize(long grow_size);

boolean clear(Integral::CMODE cmode_a = Integral::DEF_CMODE);

class-specific public methods:

constructors:
```
Wrapper(const TObject& arg);
```
assign methods:
```
boolean assign(const TObject& arg);
```

operator= methods:

Wrapper<TObject>& operator=(const TObject& arg);

private methods:

none

friend classes:

friend class WrapperDiagnose;

examples:

notes:

Unlike other classes, we have two read and write methods in dstr classes. The interface is still the same as that in other classes. The reason behind this is that we can not use "CLASS_NAME" as default argument in the read and write methods here because the data structures build the class name on the fly.