EMAN::EMObject Class Reference

EMObject is a wrapper class for types including int, float, double, etc as defined in ObjectType. More...

#include <emobject.h>

Collaboration diagram for EMAN::EMObject:

[legend]

List of all members.

Public Types
enum	ObjectType {   UNKNOWN, BOOL, UNSIGNEDINT, INT,   FLOAT, DOUBLE, STRING, EMDATA,   XYDATA, INTARRAY, FLOATARRAY, STRINGARRAY,   TRANSFORM, CTF, FLOAT_POINTER, INT_POINTER,   VOID_POINTER }
Public Member Functions
	EMObject ()
	Constructors for each type More types could be added, but all of the accompanying functions would have to be altered to ensure correct functioning.
	EMObject (bool boolean)
	EMObject (int num)
	EMObject (unsigned int num)
	EMObject (float ff)
	EMObject (double dd)
	EMObject (const char *s)
	EMObject (const string &s)
	EMObject (float *fp)
	EMObject (int *ip)
	EMObject (void *vp)
	EMObject (EMData *em)
	EMObject (XYData *xy)
	EMObject (Transform *t)
	EMObject (Ctf *ctf)
	EMObject (const vector< int > &v)
	EMObject (const vector< float > &v)
	EMObject (const vector< string > &sarray)
	EMObject (const EMObject &that)
	Copy constructor.
EMObject &	operator= (const EMObject &that)
	Assigment operator copies pointer locations (emdata, xydata, transform3d) - does not take ownership deep copies all non pointer objects.
	~EMObject ()
	Desctructor Does not free pointers.
	operator bool () const
	Conversion operators.
	operator int () const
	operator unsigned int () const
	operator float () const
	operator double () const
	operator const char * () const
	operator float * () const
	operator int * () const
	operator void * () const
	operator EMData * () const
	operator XYData * () const
	operator Transform * () const
	operator Ctf * () const
	operator vector< int > () const
	operator vector< float > () const
	operator vector< string > () const
bool	is_null () const
	Checks to see if the EMObject is interpretable This basically equates to checking to see if the type is UNKNOWN.
string	to_str () const
	Calls to_str( this->type).
ObjectType	get_type () const
	Get the ObjectType This is an enumerated type first declared in the class EMObjectTypes.
string	get_type_string () const
	Get the ObjectType as a string This is an enumerated type first declared in the class EMObjectTypes.
string	to_str (ObjectType type) const
	Write the EMObject's value to a string Literally copies into a string, except for the case where the type is boolen where it writes true of false, as opposed to 1 or 0.
Static Public Member Functions
static string	get_object_type_name (ObjectType t)
	Get an ObjectType as a string statically Can be accessed without the instantiation of a class object.
Private Member Functions
void	printInfo () const
	A debug function that prints as much information as possibe to cout.
void	init ()
Private Attributes
union {
bool   b
int   n
unsigned int   ui
float   f
double   d
float *   fp
int *   ip
void *   vp
EMData *   emdata
XYData *   xydata
};
string	str
vector< int >	iarray
vector< float >	farray
vector< string >	strarray
ObjectType	type
Static Private Attributes
static map< ObjectType, string >	type_registry
Friends
bool	operator== (const EMObject &e1, const EMObject &e2)
	Friend declaration operator== namespace EMAN2 operator== accesses private variables.
bool	operator!= (const EMObject &e1, const EMObject &e2)
	Friend declaration operator!= namespace EMAN2 operator!= accesses private variables.

---

Detailed Description

EMObject is a wrapper class for types including int, float, double, etc as defined in ObjectType.

Each type is typically used as follows ('int' is the example):

int a = 12; EMObject o(a); EMObject o2 = a; // implicit converter from int to EMObject. int a1 = o; // implicit converter from EMObject to int.

EMObjects may store pointers but they currently do not assume ownership - that is, the memory associated with a pointer is never freed by an EMObject.

This type of class design is sometimes referred to as the Variant pattern.

See the testing code in rt/emdata/test_emobject.cpp for prewritten testing code

Definition at line 122 of file emobject.h.

---

Member Enumeration Documentation

enum EMAN::EMObject::ObjectType

Enumerator:

UNKNOWN
BOOL
UNSIGNEDINT
INT
FLOAT
DOUBLE
STRING
EMDATA
XYDATA
INTARRAY
FLOATARRAY
STRINGARRAY
TRANSFORM
CTF
FLOAT_POINTER
INT_POINTER
VOID_POINTER

Definition at line 125 of file emobject.h.

                                {
                        UNKNOWN,
                        BOOL,
                        UNSIGNEDINT,
                        INT,
                        FLOAT,
                        DOUBLE,
                        STRING,
                        EMDATA,
                        XYDATA,
                        INTARRAY,
                        FLOATARRAY,
                        STRINGARRAY,
                        TRANSFORM,
                        CTF,
                        FLOAT_POINTER,
                        INT_POINTER,
                        VOID_POINTER
                };

---

Constructor & Destructor Documentation

EMObject::EMObject

(

)

Constructors for each type More types could be added, but all of the accompanying functions would have to be altered to ensure correct functioning.

Definition at line 120 of file emobject.cpp.

References init().

                   :
        d(0), type(UNKNOWN)
{
        init();
}

EMObject::EMObject

(

bool

boolean

)

Definition at line 126 of file emobject.cpp.

References init().

                               :
        b(boolean), type(BOOL)
{
        init();
}

EMObject::EMObject

(

int

num

)

Definition at line 132 of file emobject.cpp.

References init().

                          :
        n(num), type(INT)
{
        init();
}

EMObject::EMObject

(

unsigned int

num

)

Definition at line 138 of file emobject.cpp.

References init().

                                   :
        ui(num), type(UNSIGNEDINT)
{
        init();
}

EMObject::EMObject

(

float

ff

)

Definition at line 144 of file emobject.cpp.

References f, EMAN::Util::goodf(), and init().

                           :
        type(FLOAT)
{
        if(Util::goodf(&ff)) {
                f = ff;
        }
        else{
                f = 0.0f;
        }
        init();
}

EMObject::EMObject

(

double

dd

)

Definition at line 156 of file emobject.cpp.

References d, EMAN::Util::goodf(), and init().

                            :
        type(DOUBLE)
{
        if(Util::goodf(&dd)) {
                d = dd;
        }
        else{
                d = 0.0;
        }
        init();
}

EMObject::EMObject

(

const char *

s

)

Definition at line 168 of file emobject.cpp.

References init().

                                :
        str(s), type(STRING)
{
        init();
}

EMObject::EMObject

(

const string &

s

)

Definition at line 174 of file emobject.cpp.

References init().

                                   :
        str(s), type(STRING)
{
        init();
}

EMObject::EMObject

(

float *

fp

)

Definition at line 180 of file emobject.cpp.

References init().

                           :
        fp(f), type(FLOAT_POINTER)
{
        init();
}

EMObject::EMObject

(

int *

ip

)

Definition at line 186 of file emobject.cpp.

References init().

                         :
        ip(i), type(INT_POINTER)
{
        init();
}

EMObject::EMObject

(

void *

vp

)

Definition at line 192 of file emobject.cpp.

References init().

                          :
        vp(v), type(VOID_POINTER)
{
        init();
}

EMObject::EMObject

(

EMData *

em

)

Definition at line 198 of file emobject.cpp.

References init().

                                :
        emdata(em), type(EMDATA)
{
        init();
}

EMObject::EMObject

(

XYData *

xy

)

Definition at line 204 of file emobject.cpp.

References init().

00204                               :
00205         xydata(xy), type(XYDATA)
00206 {
00207         init();
00208 }
EMObject::EMObject(Transform* t) :

EMObject::EMObject

(

Transform *

t

)

Definition at line 209 of file emobject.cpp.

References init().

                               :
        farray(t->get_matrix()), type(TRANSFORM)
{
        init();
}

EMObject::EMObject

(

Ctf *

ctf

)

Definition at line 215 of file emobject.cpp.

References init().

                            :
        str(ctf->to_string()), type(CTF)
{
        init();
}

EMObject::EMObject

(

const vector< int > &

v

)

Definition at line 221 of file emobject.cpp.

References init().

                                          :
        iarray(v), type(INTARRAY)
{
        init();
}

EMObject::EMObject

(

const vector< float > &

v

)

Definition at line 227 of file emobject.cpp.

References init().

                                           :
        farray(v), type(FLOATARRAY)
{
        init();
}

EMObject::EMObject

(

const vector< string > &

sarray

)

Definition at line 233 of file emobject.cpp.

References init().

                                                 :
        strarray(sarray), type(STRINGARRAY)
{
        init();
}

EMObject::EMObject

(

const EMObject &

that

)

Copy constructor.

copies pointer locations - does not take ownership deep copies all non pointer objects

Definition at line 795 of file emobject.cpp.

{
        // init isn't necessary because that must have already called it!
        *this = that;
}

EMObject::~EMObject

(

)

Desctructor Does not free pointers.

Definition at line 118 of file emobject.cpp.

{}

---

Member Function Documentation

EMObject & EMObject::operator=

(

const EMObject &

that

)

Assigment operator copies pointer locations (emdata, xydata, transform3d) - does not take ownership deep copies all non pointer objects.

Definition at line 805 of file emobject.cpp.

References b, BOOL, CTF, d, DOUBLE, emdata, EMDATA, f, farray, FLOAT, FLOAT_POINTER, FLOATARRAY, fp, iarray, INT, INT_POINTER, INTARRAY, ip, LOGERR, n, NotExistingObjectException, str, strarray, STRING, STRINGARRAY, TRANSFORM, type, ui, UNKNOWN, UNSIGNEDINT, VOID_POINTER, vp, xydata, and XYDATA.

{

// This test breaks assignment when either the current or assigned values are (float)nan
// it's also somewhat inherently stupid, since testing for equivalence may cost as much
// as assignment.
//      if ( *this != that )
        {
                // First store the type of the input, At first I forgot to do this and it was a very
                // difficult bug to track down
                type = that.type;

//              if ( type != this_type ) throw


                switch (type)
                {
                case BOOL:
                        b = that.b;
                break;
                case INT:
                        n = that.n;
                break;
                case UNSIGNEDINT:
                        ui = that.ui;
                break;
                case FLOAT:
                        f = that.f;
                break;
                case DOUBLE:
                        d = that.d;
                break;
                case CTF:
                case STRING:
                        str = that.str;
                break;
                case FLOAT_POINTER:
                        // Warning - Pointer address copy.
                        fp = that.fp;
                break;
                case INT_POINTER:
                // Warning - Pointer address copy.
                        ip = that.ip;
                break;
                case VOID_POINTER:
                        // Warning - Pointer address copy.
                        vp = that.vp;
                break;
                case EMDATA:
                        // Warning - Pointer address copy.
                        emdata = that.emdata;
                break;
                case XYDATA:
                        // Warning - Pointer address copy.
                        xydata = that.xydata;
                break;
                case TRANSFORM:
                case FLOATARRAY:
                        farray = that.farray;
                break;
                case INTARRAY:
                        iarray = that.iarray;
                break;
                case STRINGARRAY:
                        strarray = that.strarray;
                break;
                case UNKNOWN:
                        // This is possible, nothing should happen
                        // The EMObject's default constructor has been called and
                        // as yet has no type - doing nothing is exactly as the
                        // the assignment operator should work.
                break;
                default:
                        LOGERR("No such EMObject defined");
                        throw NotExistingObjectException("EMObject", "unknown type");
                break;
                }
        }
//      else
//      {
//              cerr << "Warning - attempt to assign EMObject onto itself. No action taken" << endl;
//              cerr << "My type is " << get_object_type_name(type) << endl;
//      }

        return *this;
}

EMObject::operator bool

(

)

const

Conversion operators.

Definition at line 239 of file emobject.cpp.

References b, BOOL, d, DOUBLE, emdata, EMDATA, f, FLOAT, FLOAT_POINTER, fp, get_object_type_name(), INT, INT_POINTER, ip, n, type, TypeException, ui, UNKNOWN, UNSIGNEDINT, VOID_POINTER, xydata, and XYDATA.

{
        if (type == BOOL) {
                return b;
        }
        else if (type == INT) {
                return n != 0;
        }
        else if (type == UNSIGNEDINT) {
                return ui != 0;
        }
        else if (type == FLOAT) {
                return f != 0;
        }
        else if (type == DOUBLE) {
                return d != 0;
        }
        else if (type == EMDATA) {
                return emdata != 0;
        }
        else if (type == XYDATA) {
                return xydata != 0;
        }
        else if (type == FLOAT_POINTER) {
                return fp != 0;
        }
        else if (type == INT_POINTER) {
                return ip != 0;
        }
        else if (type == VOID_POINTER) {
                return vp != 0;
        }
//      else if (type == TRANSFORM) {
//              return transform != 0;
//      }
        // It seemed unconventional to return a boolean for the stl objects
        else {
                if (type != UNKNOWN) {
                        throw TypeException("Cannot convert to bool this data type ",
                                                                get_object_type_name(type));
                }
        }
        return 0;
}

EMObject::operator int

(

)

const

Definition at line 284 of file emobject.cpp.

References b, BOOL, d, DOUBLE, f, FLOAT, get_object_type_name(), INT, n, type, TypeException, ui, UNKNOWN, and UNSIGNEDINT.

{
        if (type == INT) {
                return n;
        }
        else if (type == UNSIGNEDINT) {
                return (int) ui;
        }
        else if (type == FLOAT) {
                return (int) f;
        }
        else if (type == DOUBLE) {
                return (int) d;
        }
        else if (type == BOOL) {
                return b?1:0;
        }
        else {
                if (type != UNKNOWN) {
                        throw TypeException("Cannot convert to int this data type ",
                                                                get_object_type_name(type));
                }
        }
        return 0;
}

EMObject::operator unsigned int

(

)

const

Definition at line 310 of file emobject.cpp.

References get_object_type_name(), type, TypeException, ui, UNKNOWN, and UNSIGNEDINT.

{
        if (type == UNSIGNEDINT) {
                return (unsigned int) ui;
        }
        else {
                if (type != UNKNOWN) {
                        throw TypeException("Cannot convert to int this data type ",
                                                                get_object_type_name(type));
                }
        }
        return 0;
}

EMObject::operator float

(

)

const

Definition at line 324 of file emobject.cpp.

References b, BOOL, d, DOUBLE, f, FLOAT, get_object_type_name(), INT, n, type, TypeException, ui, UNKNOWN, and UNSIGNEDINT.

{
        if (type == BOOL) {
                return b?1.0f:0.0f;
        }
        else if (type == FLOAT) {
                return f;
        }
        else if (type == INT) {
                return (float) n;
        }
        else if (type == UNSIGNEDINT) {
                return (float) ui;
        }
        else if (type == DOUBLE) {
                return (float) d;
        }
        else {
                if (type != UNKNOWN) {
                        throw TypeException("Cannot convert to float from this data type",
                                                                get_object_type_name(type));
                }
        }

        return 0;
}

EMObject::operator double

(

)

const

Definition at line 351 of file emobject.cpp.

References b, BOOL, d, DOUBLE, f, FLOAT, get_object_type_name(), INT, n, type, TypeException, ui, UNKNOWN, and UNSIGNEDINT.

{
        if (type == BOOL) {
        return b?1.0:0.0;
        }
        else if (type == DOUBLE) {
                return d;
        }
        else if (type == INT) {
                return (double) n;
        }
        else if (type == UNSIGNEDINT) {
                return (double) ui;
        }
        else if (type == FLOAT) {
                return (double) f;
        }
        else {
                if (type != UNKNOWN) {
                        throw TypeException("Cannot convert to double from this data type",
                                                                get_object_type_name(type));
                }
        }
        return 0;
}

EMObject::operator const char *

(

)

const

Definition at line 418 of file emobject.cpp.

References CTF, d, DOUBLE, f, FLOAT, get_object_type_name(), INT, n, str, STRING, type, TypeException, ui, UNKNOWN, and UNSIGNEDINT.

{
        if (type != STRING && type != CTF) {
                stringstream ss;
                string return_string;
                if ( type == INT )
                {
                        ss << n;
                        ss >> return_string;
                        return return_string.c_str();
                }
                if ( type == UNSIGNEDINT )
                {
                        ss << ui;
                        ss >> return_string;
                        return return_string.c_str();
                }
                else
                if ( type == FLOAT )
                {
                        ss << f;
                        ss >> return_string;
                        return return_string.c_str();
                }
                else
                if ( type == DOUBLE )
                {
                        ss << d;
                        ss >> return_string;
                        return return_string.c_str();
                }
                else if (type != UNKNOWN) {
                        throw TypeException("Cannot convert to string from this data type",
                                                                get_object_type_name(type));
                }

                return "";
        }
        return str.c_str();
}

EMObject::operator float *

(

)

const

Definition at line 392 of file emobject.cpp.

References FLOAT_POINTER, fp, get_object_type_name(), type, TypeException, and UNKNOWN.

{
        if (type != FLOAT_POINTER)
        {
                if (type != UNKNOWN)
                        throw TypeException("Cannot convert to float pointer from this data type",
                                                                get_object_type_name(type));

                return 0;
        }

        return fp;
}

EMObject::operator int *

(

)

const

Definition at line 377 of file emobject.cpp.

References get_object_type_name(), INT_POINTER, ip, type, TypeException, and UNKNOWN.

{
        if (type != INT_POINTER)
        {
                if (type != UNKNOWN)
                        throw TypeException("Cannot convert to float pointer from this data type",
                                                                get_object_type_name(type));

                return 0;
        }

        return ip;
}

EMObject::operator void *

(

)

const

Definition at line 407 of file emobject.cpp.

References emdata, EMDATA, FLOAT_POINTER, fp, get_object_type_name(), INT_POINTER, ip, type, TypeException, VOID_POINTER, xydata, and XYDATA.

{
        if (type == VOID_POINTER) return vp;
        else if (type == FLOAT_POINTER) return (void *)fp;
        else if (type == INT_POINTER) return (void *)ip;
        else if (type == EMDATA) return (void *) emdata;
        else if (type == XYDATA) return (void *) xydata;
//      else if (type == TRANSFORM) return (void *) transform;
        else throw TypeException("Cannot convert to void pointer from this data type", get_object_type_name(type));
}

EMObject::operator EMData *

(

)

const

Definition at line 459 of file emobject.cpp.

References emdata, EMDATA, get_object_type_name(), type, TypeException, and UNKNOWN.

{
        if (type != EMDATA) {
                if (type != UNKNOWN) {
                        throw TypeException("Cannot convert to EMData* from this data type",
                                   get_object_type_name(type));
                }
                return 0;
        }
        return emdata;
}

EMObject::operator XYData *

(

)

const

Definition at line 471 of file emobject.cpp.

References get_object_type_name(), type, TypeException, UNKNOWN, xydata, and XYDATA.

{
        if (type != XYDATA) {
                if (type != UNKNOWN) {
                        throw TypeException("Cannot convert to XYData* from this data type",
                                   get_object_type_name(type));
                }
                return 0;
        }
        return xydata;
}

EMObject::operator Transform *

(

)

const

Definition at line 483 of file emobject.cpp.

References farray, get_object_type_name(), EMAN::Transform::set_matrix(), TRANSFORM, type, TypeException, and UNKNOWN.

{
        if(type != TRANSFORM) {
                if(type != UNKNOWN) {
                        throw TypeException("Cannot convert to TRANSFORM* from this data type",
                                                                get_object_type_name(type));
                }
        }
        Transform * transform = new Transform();
        transform->set_matrix(farray);
        return transform;
}

EMObject::operator Ctf *

(

)

const

Definition at line 496 of file emobject.cpp.

References EMAN::Ctf::from_string(), and str.

{
/*      if(type != CTF) {
                if(type != CTF) {
                        throw TypeException("Cannot convert to TRANSFORM* from this data type",
                                                                get_object_type_name(type));
                }
        }*/
        Ctf * ctf = 0;
        if(str[0] == 'O') {
                ctf = new EMAN1Ctf();
                ctf->from_string(str);
        }
        else if(str[0] == 'E') {
                ctf = new EMAN2Ctf();
                ctf->from_string(str);
        }
        return ctf;
}

EMObject::operator vector< int >

(

)

const

Definition at line 516 of file emobject.cpp.

References get_object_type_name(), iarray, INTARRAY, type, TypeException, and UNKNOWN.

{
    if( type != INTARRAY )
    {
        if( type != UNKNOWN ) {
                throw TypeException("Cannot convert to vector<int> from this data type", get_object_type_name(type) );
                }
                return vector<int>();
    }
    return iarray;
}

EMObject::operator vector< float >

(

)

const

Definition at line 528 of file emobject.cpp.

References farray, FLOATARRAY, get_object_type_name(), type, TypeException, and UNKNOWN.

{
        if (type != FLOATARRAY) {
                if (type != UNKNOWN) {
                        throw TypeException("Cannot convert to vector<float> from this data type",
                                                                get_object_type_name(type));
                }
                return vector < float >();
        }
        return farray;
}

EMObject::operator vector< string >

(

)

const

Definition at line 540 of file emobject.cpp.

References get_object_type_name(), strarray, STRINGARRAY, type, TypeException, and UNKNOWN.

{
        if (type != STRINGARRAY) {
                if (type != UNKNOWN) {
                        throw TypeException("Cannot convert to vector<string> from this data type",
                                                                get_object_type_name(type));
                }
                return vector<string>();
        }
        return strarray;
}

bool EMObject::is_null

(

)

const

Checks to see if the EMObject is interpretable This basically equates to checking to see if the type is UNKNOWN.

Definition at line 552 of file emobject.cpp.

References type, and UNKNOWN.

Referenced by EMAN::EMUtil::dump_dict().

{
        return (type == UNKNOWN);
}

string EMObject::to_str

(

)

const

Calls to_str( this->type).

Definition at line 557 of file emobject.cpp.

References type.

Referenced by EMAN::EMUtil::dump_dict(), and printInfo().

{
        return to_str(type);
}

ObjectType EMAN::EMObject::get_type

(

)

const [inline]

Get the ObjectType This is an enumerated type first declared in the class EMObjectTypes.

Definition at line 218 of file emobject.h.

References type.

Referenced by EMAN::Transform::set_params(), and EMAN::Transform::set_params_inverse().

{ return type; }

string EMAN::EMObject::get_type_string

(

)

const [inline]

Get the ObjectType as a string This is an enumerated type first declared in the class EMObjectTypes.

Definition at line 224 of file emobject.h.

References get_object_type_name(), and type.

{ return get_object_type_name(type); }

string EMObject::to_str

(

ObjectType

type

)

const

Write the EMObject's value to a string Literally copies into a string, except for the case where the type is boolen where it writes true of false, as opposed to 1 or 0.

Definition at line 562 of file emobject.cpp.

References b, BOOL, CTF, d, DOUBLE, EMDATA, f, FLOAT, FLOAT_POINTER, FLOATARRAY, INT, INTARRAY, LOGERR, n, NotExistingObjectException, str, STRING, STRINGARRAY, TRANSFORM, ui, UNKNOWN, UNSIGNEDINT, VOID_POINTER, and XYDATA.

{
        if (argtype == STRING) {
                return str;
        }
        else {
                char tmp_str[32];
                if (argtype == BOOL) {
                        if (b)
                                sprintf(tmp_str, "true");
                        else
                                sprintf(tmp_str, "false");
                }
                else if (argtype == INT) {
                        sprintf(tmp_str, "%d", n);
                }
                else if (argtype == UNSIGNEDINT) {
                        sprintf(tmp_str, "%d", ui);
                }
                else if (argtype == FLOAT) {
                        sprintf(tmp_str, "%f", f);
                }
                else if (argtype == DOUBLE) {
                        sprintf(tmp_str, "%f", d);
                }
                else if (argtype == EMDATA) {
                        sprintf(tmp_str, "EMDATA");
                }
                else if (argtype == FLOAT_POINTER) {
                        sprintf(tmp_str, "FLOAT_POINTER");
                }
                else if (argtype == INT) {
                        sprintf(tmp_str, "INT_POINTER");
                }
                else if (argtype == VOID_POINTER) {
                        sprintf(tmp_str, "VOID_POINTER");
                }
                else if (argtype == XYDATA) {
                        sprintf(tmp_str, "XYDATA");
                }
                else if (argtype == INTARRAY) {
                        sprintf(tmp_str, "INTARRAY");
                }
                else if (argtype == FLOATARRAY) {
                        sprintf(tmp_str, "FLOATARRAY");
                }
                else if (argtype == STRINGARRAY) {
                        sprintf(tmp_str, "STRINGARRAY");
                }
                else if (argtype == TRANSFORM) {
                        sprintf(tmp_str, "TRANSFORMD");
                }
                else if (argtype == CTF) {
                        sprintf(tmp_str, "CTF");
                }
                else if (argtype == UNKNOWN) {
                        sprintf(tmp_str, "UNKNOWN");
                }
                else {
                        LOGERR("No such EMObject defined");
                        throw NotExistingObjectException("EMObject", "unknown type");
                }
                return string(tmp_str);
        }
}

string EMObject::get_object_type_name

(

ObjectType

t

)

[static]

Get an ObjectType as a string statically Can be accessed without the instantiation of a class object.

Definition at line 628 of file emobject.cpp.

References BOOL, CTF, DOUBLE, EMDATA, FLOAT, FLOAT_POINTER, FLOATARRAY, INT, INT_POINTER, INTARRAY, LOGERR, NotExistingObjectException, STRING, STRINGARRAY, TRANSFORM, type_registry, UNKNOWN, UNSIGNEDINT, VOID_POINTER, and XYDATA.

Referenced by get_type_string(), operator bool(), operator const char *(), operator double(), operator EMData *(), operator float(), operator float *(), operator int(), operator int *(), operator Transform *(), operator unsigned int(), operator vector< float >(), operator vector< int >(), operator vector< string >(), operator void *(), operator XYData *(), and EMAN::TypeDict::put().

{
#ifdef _WIN32
        if (t == BOOL) {
                return "BOOL";
        }else
        if ( t == INT){
                return "INT";
        }else
        if ( t == UNSIGNEDINT){
                return "UNSIGNEDINT";
        } else
        if ( t == FLOAT){
                return "FLOAT";
        } else
        if ( t == DOUBLE){
                return "DOUBLE";
        }else
        if ( t == STRING){
                return "STRING";
        }else
        if ( t == EMDATA){
                return "EMDATA";
        }
        else
        if ( t == XYDATA){
                return "XYDATA";
        }else
        if ( t == INTARRAY){
                return "INTARRAY";
        }else
        if ( t == FLOATARRAY){
                return "FLOATARRAY";
        } else
        if ( t == STRINGARRAY){
                return "STRINGARRAY";
        }else
        if ( t == TRANSFORM){
                return "TRANSFORM";
        }else
        if ( t == CTF){
                return "CTF";
        }else
        if ( t == FLOAT_POINTER){
                return "FLOAT_POINTER";
        }else
        if ( t == INT_POINTER){
                return "INT_POINTER";
        }else
        if ( t == UNKNOWN){
                return "UNKNOWN";
        } else
        if ( t == VOID_POINTER){
                return "VOID_POINTER";
        }
        else {
                LOGERR("No such EMObject defined");
                throw NotExistingObjectException("EMObject", "unknown type");
        }

#else

        if  ( type_registry.find(t) != type_registry.end() )
                return type_registry[t];
        else
                LOGERR("No such EMObject defined");
                throw NotExistingObjectException("EMObject", "unknown type");
#endif  //_WIN32
}

void EMObject::printInfo

(

)

const [private]

A debug function that prints as much information as possibe to cout.

Definition at line 106 of file emobject.cpp.

References to_str(), type, and type_registry.

{
        cout << "The address of my type is " << &type << endl;
        cout << " Now printing the enumerated values in type_registry " << endl;
        for( map< ObjectType, string>::const_iterator it = type_registry.begin(); it != type_registry.end(); ++it )
        {
                cout << it->first << " " << it->second << endl;
        }
        cout << "My type is " << to_str(type) << " and its enumerated value is " << type << endl;
        cout << "The address of the static type registry is " << &type_registry <<", it should be same for all EMObjects" << endl;
}

void EMObject::init

(

)

[private]

Definition at line 77 of file emobject.cpp.

References BOOL, CTF, DOUBLE, EMDATA, FLOAT, FLOAT_POINTER, FLOATARRAY, INT, INT_POINTER, INTARRAY, STRING, STRINGARRAY, TRANSFORM, type_registry, UNKNOWN, UNSIGNEDINT, VOID_POINTER, and XYDATA.

Referenced by EMObject().

{
        static bool first_construction = true;
        if ( first_construction )
        {
                // Initialize the the type registry once and for all
                type_registry[BOOL] = "BOOL";
                type_registry[INT] = "INT";
                type_registry[UNSIGNEDINT] = "UNSIGNEDINT";
                type_registry[FLOAT] = "FLOAT";
                type_registry[DOUBLE] = "DOUBLE";
                type_registry[STRING] = "STRING";
                type_registry[EMDATA] = "EMDATA";
                type_registry[XYDATA] = "XYDATA";
                type_registry[INTARRAY] = "INTARRAY";
                type_registry[FLOATARRAY] = "FLOATARRAY";
                type_registry[STRINGARRAY] = "STRINGARRAY";
                type_registry[TRANSFORM] = "TRANFORM";
                type_registry[CTF] = "CTF";
                type_registry[FLOAT_POINTER] = "FLOAT_POINTER";
                type_registry[INT_POINTER] = "INT_POINTER";
                type_registry[UNKNOWN] = "UNKNOWN";
                type_registry[VOID_POINTER] = "VOID_POINTER";
                first_construction = false;
        }
}

---

Friends And Related Function Documentation

bool operator==	(	const EMObject &	e1,
		const EMObject &	e2
	)			[friend]

Friend declaration operator== namespace EMAN2 operator== accesses private variables.

Definition at line 698 of file emobject.cpp.

{

        if (e1.type != e2.type) {
                return false;
        }

        switch (e1.type) {
        case  EMObject::BOOL:
                return (e1.b == e2.b);
        break;
        case  EMObject::INT:
                return (e1.n == e2.n);
        break;
        case  EMObject::UNSIGNEDINT:
                return (e1.ui == e2.ui);
        break;
        case  EMObject::FLOAT:
                return (e1.f == e2.f);
        break;
        case  EMObject::DOUBLE:
                return (e1.d == e2.d);
        break;
        case EMObject::CTF:
        case  EMObject::STRING:
                return (e1.str == e2.str);
        break;
        case  EMObject::FLOAT_POINTER:
                return (e1.fp == e2.fp);
        break;
        case  EMObject::INT_POINTER:
                return (e1.ip == e2.ip);
        break;
        case  EMObject::VOID_POINTER:
                return (e1.vp == e2.vp);
        break;
        case  EMObject::EMDATA:
                return (e1.emdata == e2.emdata);
        break;
        case  EMObject::XYDATA:
                return (e1.xydata == e2.xydata);
        break;
        case  EMObject::TRANSFORM:
        case  EMObject::FLOATARRAY:
                if (e1.farray.size() == e2.farray.size()) {
                        for (size_t i = 0; i < e1.farray.size(); i++) {
                                if (e1.farray[i] != e2.farray[i]) {
                                        return false;
                                }
                        }
                        return true;
                }
                else {
                        return false;
                }
        break;
        case  EMObject::INTARRAY:
                if (e1.iarray.size() == e2.iarray.size()) {
                        for (size_t i = 0; i < e1.iarray.size(); i++) {
                                if (e1.iarray[i] != e2.iarray[i]) {
                                        return false;
                                }
                        }
                        return true;
                }
        break;
        case  EMObject::STRINGARRAY:
                if (e1.strarray.size() == e2.strarray.size()) {
                        for (size_t i = 0; i < e1.strarray.size(); i++) {
                                if (e1.strarray[i] != e2.strarray[i]) {
                                        return false;
                                }
                        }
                        return true;
                }
                else {
                        return false;
                }
        break;
        case  EMObject::UNKNOWN:
                // UNKNOWN really means "no type" and if two objects both have
                // type UNKNOWN they really are the same
                return (e1.type == e2.type);
        break;
        default:
                return false;
        break;
        }
        return false;
}

bool operator!=	(	const EMObject &	e1,
		const EMObject &	e2
	)			[friend]

Friend declaration operator!= namespace EMAN2 operator!= accesses private variables.

Definition at line 789 of file emobject.cpp.

{
        return !(e1 == e2);
}

---

Member Data Documentation

bool EMAN::EMObject::b

Definition at line 252 of file emobject.h.

Referenced by operator bool(), operator double(), operator float(), operator int(), operator=(), EMAN::operator==(), and to_str().

int EMAN::EMObject::n

Definition at line 253 of file emobject.h.

Referenced by operator bool(), operator const char *(), operator double(), operator float(), operator int(), operator=(), EMAN::operator==(), and to_str().

unsigned int EMAN::EMObject::ui

Definition at line 254 of file emobject.h.

Referenced by operator bool(), operator const char *(), operator double(), operator float(), operator int(), operator unsigned int(), operator=(), EMAN::operator==(), and to_str().

float EMAN::EMObject::f

Definition at line 255 of file emobject.h.

Referenced by EMAN::CtfAverager::add_image(), EMAN::FRCCmp::cmp(), EMObject(), EMAN::nn4Reconstructor::insert_slice(), EMAN::PointArray::match_points(), operator bool(), operator const char *(), operator double(), operator float(), operator int(), operator=(), EMAN::operator==(), EMAN::Util::pad(), EMAN::ToMassCenterProcessor::process_inplace(), EMAN::EMData::rotate_translate(), and to_str().

double EMAN::EMObject::d

Definition at line 256 of file emobject.h.

Referenced by EMObject(), operator bool(), operator const char *(), operator double(), operator float(), operator int(), operator=(), EMAN::operator==(), and to_str().

float* EMAN::EMObject::fp

Definition at line 257 of file emobject.h.

Referenced by operator bool(), operator float *(), operator void *(), operator=(), and EMAN::operator==().

int* EMAN::EMObject::ip

Definition at line 258 of file emobject.h.

Referenced by operator bool(), operator int *(), operator void *(), operator=(), and EMAN::operator==().

void* EMAN::EMObject::vp

Definition at line 259 of file emobject.h.

Referenced by operator=(), and EMAN::operator==().

EMData* EMAN::EMObject::emdata

Definition at line 260 of file emobject.h.

Referenced by operator bool(), operator EMData *(), operator void *(), operator=(), and EMAN::operator==().

XYData* EMAN::EMObject::xydata

Definition at line 261 of file emobject.h.

Referenced by operator bool(), operator void *(), operator XYData *(), operator=(), and EMAN::operator==().

union { ... } [private]

string EMAN::EMObject::str [private]

Definition at line 264 of file emobject.h.

Referenced by operator const char *(), operator Ctf *(), operator=(), EMAN::operator==(), and to_str().

vector< int > EMAN::EMObject::iarray [private]

Definition at line 265 of file emobject.h.

Referenced by operator vector< int >(), operator=(), and EMAN::operator==().

vector< float > EMAN::EMObject::farray [private]

Definition at line 266 of file emobject.h.

Referenced by operator Transform *(), operator vector< float >(), operator=(), and EMAN::operator==().

vector< string> EMAN::EMObject::strarray [private]

Definition at line 267 of file emobject.h.

Referenced by operator vector< string >(), operator=(), and EMAN::operator==().

ObjectType EMAN::EMObject::type [private]

Definition at line 268 of file emobject.h.

Referenced by get_type(), get_type_string(), is_null(), operator bool(), operator const char *(), operator double(), operator EMData *(), operator float(), operator float *(), operator int(), operator int *(), operator Transform *(), operator unsigned int(), operator vector< float >(), operator vector< int >(), operator vector< string >(), operator void *(), operator XYData *(), operator=(), EMAN::operator==(), printInfo(), and to_str().

map< EMObject::ObjectType, string > EMObject::type_registry [static, private]

Definition at line 276 of file emobject.h.

Referenced by get_object_type_name(), init(), and printInfo().

---

The documentation for this class was generated from the following files:

• emobject.h
• emobject.cpp