NeL: NLAIC Namespace Reference

00050         {
00051                 return registry->createInstance(ident);
00052         }

00075         {
00076                 CPyTemplateDef<T> *ThisClass;
00077                 ThisClass = new CPyTemplateDef<T>(o);
00078                 if(ThisClass == NULL) return NULL;              
00079                 ThisClass->Instance = o;
00080                 ThisClass->ob_type = defType;
00081                 _Py_NewReference((PyObject *)ThisClass);
00082                 return ThisClass;
00083         }

00059         {
00060                 return DefaultIIO;
00061         }

00035         {
00036                 if(registry == NULL) 
00037                 {
00038                         return (registry = new CRegistry);
00039                 }
00040                 else
00041                         return registry;
00042         }

00055         {
00056                 if ( registry == NULL ) registry= new CRegistry;
00057         }

00526         {
00527                 o.save(os);
00528                 return os;
00529         }

00275         {               
00276                 o.serial(os);
00277                 return os;
00278         }

00533         {
00534                 o.load(is);
00535                 return is;
00536         }

00516         {
00517                 o.load(is);
00518                 return is;
00519         }

00064         {               
00065                 char    temp[64*1024];
00066                 va_list argument;
00067                 va_start (argument, str);
00068                 
00069                 vsprintf(temp, str, argument);
00070                 if(DefaultIIO != NULL) 
00071                         DefaultIIO->Echo(temp);
00072                 else
00073                 {
00074                         fprintf(stderr,temp);
00075                         fflush(stderr);
00076                 }
00077         }

00045         {
00046                 return registry->registerClass(ident,factoryClass);
00047         }

00059         {
00060                 delete registry;
00061         }

00054         {
00055                 DefaultIIO = io;
00056         }

00041         {               
00042                 char    temp[64*1024];
00043                 va_list argument;
00044                 va_start (argument, str);
00045                 
00046                 vsprintf(temp, str, argument);
00047                 char *s = new char [strlen(temp)+1];
00048                 strcpy(s,temp);
00049                 return s;
00050         }

00080         {
00081                 char    temp[64*1024];
00082                 va_list argument;
00083                 va_start (argument, str);
00084                 
00085                 vsprintf(temp, str, argument);                  
00086 
00087                 return std::string(temp);
00088 
00089         }


Data Structures
class	CBinaryType
class	CIdentType
class	CIdentTypeAlloc
class	CPyTemplateDef
class	CRegistry
struct	CRegistry::CRegistryClass
	Private structure to store data in the std::map. More...
class	CSelfClassFactory
class	CTypeOfObject
class	CTypeOfOperator
class	IBasicInterface
class	IBasicType
class	IClassFactory
class	IIO
class	IPointerGestion
Basic stream method utility.
NLMISC::IStream &	operator<< (NLMISC::IStream &os, IBasicInterface &o)
	Write an IBasicInterface to a stream.
NLMISC::IStream &	operator<< (NLMISC::IStream &os, CIdentType &o)
	Read an CIdentType from a stream.
NLMISC::IStream &	operator>> (NLMISC::IStream &is, IBasicInterface &o)
	read an IBasicInterface from a stream.
NLMISC::IStream &	operator>> (NLMISC::IStream &is, CIdentTypeAlloc &o)
	Read an CIdentTypeAlloc from a stream.
Enumerations
enum	PyMemDeleteType { unDeleteMemory, deleteMemory }
Functions
IBasicInterface *	createInstance (const CIdentType &ident)
	Creat new instance from the CRegistry static object.
template<class T> CPyTemplateDef< T > *	CreatePyObjectInstance (T o, PyTypeObject defType)
const IIO *	getDefaultIIO ()
CRegistry *	getRegistry ()
	Get the local static CRegistry object define for all object.
void	initRegistry ()
	Initialize the CRegistry static object. That mean: if not null create new one else delete old one and build new one.
void	Out (const char *str,...)
sint32	registerClass (const CIdentType &ident, const IClassFactory &factoryClass)
	Register an object in the CRegistry static object.
void	releaseRegistry ()
	Remove the static CRegistry object.
void	setDefaultIIO (const IIO *io)
char *	stringBuild (const char *str,...)
	this method give an char pointer hows it contents a string define by a const char* same as printf. It use for initialise string objects.
std::string	stringGetBuild (const char *str,...)
	this method give an char pointer hows it contents a string define by a const char* same as printf. It use for initialise string objects.
Variables
const IIO *	DefaultIIO = NULL
CRegistry *	registry = NULL

NLAIC Namespace Reference

Data Structures

Basic stream method utility.

Enumerations

Functions

Variables

Enumeration Type Documentation

Function Documentation

Variable Documentation