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]

Public Types
enum	ObjectType { UNKNOWN , BOOL , SHORT , UNSIGNEDINT , INT , FLOAT , DOUBLE , STRING , EMDATA , XYDATA , INTARRAY , FLOATARRAY , STRINGARRAY , TRANSFORM , CTF , FLOAT_POINTER , INT_POINTER , VOID_POINTER , TRANSFORMARRAY }

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. More...

	EMObject (bool boolean)

	EMObject (short)

	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 vector< Transform > &tarray)

	EMObject (const EMObject &that)
	Copy constructor. More...

EMObject &	operator= (const EMObject &that)
	Assigment operator copies pointer locations (emdata, xydata, transform) - does not take ownership deep copies all non pointer objects. More...

	~EMObject ()
	Desctructor Does not free pointers. More...

	operator bool () const
	Conversion operators. More...

	operator short () const

	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

	operator vector< Transform > () 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. More...

string	to_str () const
	Calls to_str( this->type) More...

ObjectType	get_type () const
	Get the ObjectType This is an enumerated type first declared in the class EMObjectTypes. More...

string	get_type_string () const
	Get the ObjectType as a string This is an enumerated type first declared in the class EMObjectTypes. More...

void	force_CTF ()

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. More...

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. More...

Private Member Functions
void	printInfo () const
	A debug function that prints as much information as possibe to cout. More...

Static Private Member Functions
static map< ObjectType, string >	init ()

Private Attributes
union {
bool b

short si

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

vector< Transform >	transformarray

ObjectType	type

Static Private Attributes
static map< ObjectType, string >	type_registry = init()

Friends
bool	operator== (const EMObject &e1, const EMObject &e2)
	Friend declaration operator== namespace EMAN2 operator== accesses private variables. More...

bool	operator!= (const EMObject &e1, const EMObject &e2)
	Friend declaration operator!= namespace EMAN2 operator!= accesses private variables. More...

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

◆ ObjectType

enum EMAN::EMObject::ObjectType

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

Definition at line 125 of file emobject.h.

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

Constructor & Destructor Documentation

◆ EMObject() [1/21]

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 131 of file emobject.cpp.

                   :
        d(0), type(UNKNOWN)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [2/21]

EMObject::EMObject ( bool boolean )

Definition at line 140 of file emobject.cpp.

                               :
        b(boolean), type(BOOL)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [3/21]

EMObject::EMObject ( short sint )

Definition at line 149 of file emobject.cpp.

                             :
        si(sint), type(SHORT)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [4/21]

EMObject::EMObject ( int num )

Definition at line 158 of file emobject.cpp.

                          :
        n(num), type(INT)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [5/21]

EMObject::EMObject ( unsigned int num )

Definition at line 167 of file emobject.cpp.

                                   :
        ui(num), type(UNSIGNEDINT)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [6/21]

EMObject::EMObject ( float ff )

Definition at line 176 of file emobject.cpp.

                           :
        type(FLOAT)
{
 
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p\n",(int)allemobjlist.size(),this);
#endif
        if(Util::goodf(&ff)) {
                f = ff;
        }
        else{
                f = 0.0f;
        }
}

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

◆ EMObject() [7/21]

EMObject::EMObject ( double dd )

Definition at line 192 of file emobject.cpp.

                            :
        type(DOUBLE)
{
 
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p\n",(int)allemobjlist.size(),this);
#endif
        if(Util::goodf(&dd)) {
                d = dd;
        }
        else{
                d = 0.0;
        }
}

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

◆ EMObject() [8/21]

EMObject::EMObject ( const char * s )

Definition at line 208 of file emobject.cpp.

                                :
        str(s), type(STRING)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p c*\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [9/21]

EMObject::EMObject ( const string & s )

Definition at line 217 of file emobject.cpp.

                                   :
        str(s), type(STRING)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p s\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [10/21]

EMObject::EMObject ( float * fp )

Definition at line 226 of file emobject.cpp.

                           :
        fp(f), type(FLOAT_POINTER)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p f*\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [11/21]

EMObject::EMObject ( int * ip )

Definition at line 235 of file emobject.cpp.

                         :
        ip(i), type(INT_POINTER)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p i*\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [12/21]

EMObject::EMObject ( void * vp )

Definition at line 244 of file emobject.cpp.

                          :
        vp(v), type(VOID_POINTER)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p v*\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [13/21]

EMObject::EMObject ( EMData * em )

Definition at line 253 of file emobject.cpp.

                                :
        emdata(em), type(EMDATA)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p emd\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [14/21]

EMObject::EMObject ( XYData * xy )

Definition at line 262 of file emobject.cpp.

                              :
        xydata(xy), type(XYDATA)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p xyd\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [15/21]

EMObject::EMObject ( Transform * t )

Definition at line 271 of file emobject.cpp.

                               :
        farray(t->get_matrix()), type(TRANSFORM)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p xf\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [16/21]

EMObject::EMObject ( Ctf * ctf )

Definition at line 280 of file emobject.cpp.

                            :
        str(ctf->to_string()), type(CTF)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p ctf\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [17/21]

EMObject::EMObject ( const vector< int > & v )

Definition at line 289 of file emobject.cpp.

                                          :
        iarray(v), type(INTARRAY)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p ia\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [18/21]

EMObject::EMObject ( const vector< float > & v )

Definition at line 298 of file emobject.cpp.

                                           :
        farray(v), type(FLOATARRAY)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p fa\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [19/21]

EMObject::EMObject ( const vector< string > & sarray )

Definition at line 307 of file emobject.cpp.

                                                :
        strarray(sarray), type(STRINGARRAY)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p sa\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [20/21]

EMObject::EMObject ( const vector< Transform > & tarray )

Definition at line 316 of file emobject.cpp.

                                                   :
        transformarray(tarray), type(TRANSFORMARRAY)
{
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p xfa\n",(int)allemobjlist.size(),this);
#endif
}

◆ EMObject() [21/21]

EMObject::EMObject ( const EMObject & that )

Copy constructor.

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

Definition at line 879 of file emobject.cpp.

{
        // init isn't necessary because that must have already called it!
        *this = that;
#ifdef MEMDEBUG
        allemobjlist.insert(this);
        printf("  +(%6d) %p\n",(int)allemobjlist.size(),this);
#endif
}

◆ ~EMObject()

EMObject::~EMObject ( )

Desctructor Does not free pointers.

Definition at line 124 of file emobject.cpp.

                    {
#ifdef MEMDEBUG
        allemobjlist.erase(this);
        printf("  -(%6d) %p\n",(int)allemobjlist.size(),this);
#endif
}

Member Function Documentation

◆ force_CTF()

void EMAN::EMObject::force_CTF ( )

inline

Definition at line 233 of file emobject.h.

233{ type=CTF; }

References CTF, and type.

◆ get_object_type_name()

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 761 of file emobject.cpp.

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

References LOGERR, NotExistingObjectException, and type_registry.

Referenced by get_type_string(), and EMAN::TypeDict::put().

◆ get_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 224 of file emobject.h.

224{ return type; }

References type.

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

◆ get_type_string()

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 230 of file emobject.h.

230{ return get_object_type_name(type); }

EMAN::EMObject::get_object_type_name

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.

Definition: emobject.cpp:761

References get_object_type_name(), and type.

◆ init()

map< EMObject::ObjectType, string > EMObject::init ( )

staticprivate

Definition at line 78 of file emobject.cpp.

{
        map< EMObject::ObjectType, string> mymap;
        static bool first_construction = true;
        if ( first_construction )
        {
                // Initialize the the type registry once and for all
                mymap[BOOL] = "BOOL";
                mymap[SHORT] = "SHORT";
                mymap[INT] = "INT";
                mymap[UNSIGNEDINT] = "UNSIGNEDINT";
                mymap[FLOAT] = "FLOAT";
                mymap[DOUBLE] = "DOUBLE";
                mymap[STRING] = "STRING";
                mymap[EMDATA] = "EMDATA";
                mymap[XYDATA] = "XYDATA";
                mymap[INTARRAY] = "INTARRAY";
                mymap[FLOATARRAY] = "FLOATARRAY";
                mymap[STRINGARRAY] = "STRINGARRAY";
                mymap[TRANSFORM] = "TRANSFORM";
                mymap[CTF] = "CTF";
                mymap[FLOAT_POINTER] = "FLOAT_POINTER";
                mymap[INT_POINTER] = "INT_POINTER";
                mymap[UNKNOWN] = "UNKNOWN";
                mymap[VOID_POINTER] = "VOID_POINTER";
                mymap[TRANSFORMARRAY] = "TRANSFORMARRAY";
                first_construction = false;
        }
 
        return mymap;
}

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

◆ is_null()

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 679 of file emobject.cpp.

{
        return (type == UNKNOWN);
}

References type, and UNKNOWN.

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

◆ operator bool()

EMObject::operator bool ( ) const

Conversion operators.

Definition at line 325 of file emobject.cpp.

{
        if (type == BOOL) {
                return b;
        }
        else if (type == SHORT) {
                return si != 0;
        }
        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;
}

References TypeException.

◆ operator const char *()

EMObject::operator const char * ( ) const

Definition at line 533 of file emobject.cpp.

{
        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();
}

References TypeException.

◆ operator Ctf *()

EMObject::operator Ctf * ( ) const

Definition at line 611 of file emobject.cpp.

{
/*      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;
}

References EMAN::Ctf::from_string().

◆ operator double()

EMObject::operator double ( ) const

Definition at line 463 of file emobject.cpp.

{
        if (type == BOOL) {
        return b?1.0:0.0;
        }
        else if (type == DOUBLE) {
                return d;
        }
        else if (type == SHORT) {
                return si;
        }
        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;
}

References TypeException.

◆ operator EMData *()

EMObject::operator EMData * ( ) const

Definition at line 574 of file emobject.cpp.

{
        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;
}

References TypeException.

◆ operator float()

EMObject::operator float ( ) const

Definition at line 430 of file emobject.cpp.

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

References TypeException.

◆ operator float *()

EMObject::operator float * ( ) const

Definition at line 507 of file emobject.cpp.

{
        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;
}

References TypeException.

◆ operator int()

EMObject::operator int ( ) const

Definition at line 387 of file emobject.cpp.

{
        if (type == INT) {
                return n;
        }
        else if (type == SHORT) {
                return si;
        }
        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;
}

References TypeException.

◆ operator int *()

EMObject::operator int * ( ) const

Definition at line 492 of file emobject.cpp.

{
        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;
}

References TypeException.

◆ operator short()

EMObject::operator short ( ) const

Definition at line 373 of file emobject.cpp.

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

References TypeException.

◆ operator Transform *()

EMObject::operator Transform * ( ) const

Definition at line 598 of file emobject.cpp.

{
        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;
}

References EMAN::Transform::set_matrix(), and TypeException.

◆ operator unsigned int()

EMObject::operator unsigned int ( ) const

Definition at line 416 of file emobject.cpp.

{
        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;
}

References TypeException.

◆ operator vector< float >()

EMObject::operator vector< float > ( ) const

Definition at line 643 of file emobject.cpp.

{
        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;
}

References TypeException.

◆ operator vector< int >()

EMObject::operator vector< int > ( ) const

Definition at line 631 of file emobject.cpp.

{
    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;
}

References TypeException.

◆ operator vector< string >()

EMObject::operator vector< string > ( ) const

Definition at line 655 of file emobject.cpp.

{
        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;
}

References TypeException.

◆ operator vector< Transform >()

EMObject::operator vector< Transform > ( ) const

Definition at line 667 of file emobject.cpp.

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

References TypeException.

◆ operator void *()

EMObject::operator void * ( ) const

Definition at line 522 of file emobject.cpp.

{
        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));
}

References TypeException.

◆ operator XYData *()

EMObject::operator XYData * ( ) const

Definition at line 586 of file emobject.cpp.

{
        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;
}

References TypeException.

◆ operator=()

EMObject & EMObject::operator= ( const EMObject & that )

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

Definition at line 893 of file emobject.cpp.

{
 
// 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 SHORT:
                        si = that.si;
                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 TRANSFORMARRAY:
                        transformarray = that.transformarray;
                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;
}

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

◆ printInfo()

void EMObject::printInfo ( ) const

private

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

Definition at line 112 of file emobject.cpp.

{
        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;
}

References to_str(), type, and type_registry.

◆ to_str() [1/2]

string EMObject::to_str ( ) const

Calls to_str( this->type)

Definition at line 684 of file emobject.cpp.

{
        return to_str(type);
}

References to_str(), and type.

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

◆ to_str() [2/2]

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 689 of file emobject.cpp.

{
        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 == SHORT) {
                        sprintf(tmp_str, "%hd", si);
                }
                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_POINTER) {
                        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, "TRANSFORM");
                }
                else if (argtype == TRANSFORMARRAY) {
                        sprintf(tmp_str, "TRANSFORMARRAY");
                }
                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);
        }
}