Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

emobject.h File Reference

#include <map>
#include <set>
#include <vector>
#include <string>
#include <utility>
#include <algorithm>
#include <iterator>
#include "log.h"
#include "exception.h"
#include <iostream>
#include <cctype>

Include dependency graph for emobject.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace  EMAN

Classes

class  EMAN::EMConsts
class  EMAN::EMObject
 EMObject is a wrapper class for types including int, float, double, etc as defined in ObjectType. More...
class  EMAN::TypeDict
 TypeDict is a dictionary to store <string, EMObject::ObjectType> pair. More...
class  EMAN::Dict
 Dict is a dictionary to store <string, EMObject> pair. More...
class  EMAN::Dict::iterator
 Non const iterator support for the Dict object This is just a wrapper, everything is inherited from the map<string,EMObject>::iterator so the interface is the same as you would expect i.e for ( Dict::iterator it = params.begin(); it != params.end(); ++it ). More...
class  EMAN::Dict::const_iterator
 Const iterator support for the Dict object This is just a wrapper, everything is inherited from the map<string,EMObject>::cons_iterator so the interface is the same as you would expect i.e for ( Dict::const_iterator it = params.begin(); it != params.end(); ++it ). More...
class  EMAN::Factory< T >
 Factory is used to store objects to create new instances. More...
class  EMAN::FactoryBase
 A class one may inherit from to ensure that the responsibilities of being incorporated into an EMAN2::Factory are met. More...

Defines

#define eman__object__h__   1
 
Id
emobject.h,v 1.96 2011/02/18 23:52:33 gtang Exp


Enumerations

enum  MapInfoType {
  NORMAL, ICOS2F_FIRST_OCTANT, ICOS2F_FULL, ICOS2F_HALF,
  ICOS3F_HALF, ICOS3F_FULL, ICOS5F_HALF, ICOS5F_FULL,
  ICOS_UNKNOWN
}

Functions

bool operator== (const EMObject &e1, const EMObject &e2)
bool operator!= (const EMObject &e1, const EMObject &e2)
bool operator== (const Dict &d1, const Dict &d2)
bool operator!= (const Dict &d1, const Dict &d2)
template<class T>
void dump_factory ()
template<class T>
map< string, vector< string > > dump_factory_list ()


Define Documentation

#define eman__object__h__   1
 

Id
emobject.h,v 1.96 2011/02/18 23:52:33 gtang Exp

Definition at line 37 of file emobject.h.


Enumeration Type Documentation

enum MapInfoType
 

Enumeration values:
NORMAL 
ICOS2F_FIRST_OCTANT 
ICOS2F_FULL 
ICOS2F_HALF 
ICOS3F_HALF 
ICOS3F_FULL 
ICOS5F_HALF 
ICOS5F_FULL 
ICOS_UNKNOWN 

Definition at line 97 of file emobject.h.

00097                          {
00098                 NORMAL,
00099                 ICOS2F_FIRST_OCTANT,
00100                 ICOS2F_FULL,
00101                 ICOS2F_HALF,
00102                 ICOS3F_HALF,
00103                 ICOS3F_FULL,
00104                 ICOS5F_HALF,
00105                 ICOS5F_FULL,
00106                 ICOS_UNKNOWN
00107         };


Function Documentation

template<class T>
void dump_factory  ) 
 

Definition at line 829 of file emobject.h.

References EMAN::TypeDict::dump().

00830         {
00831                 vector < string > item_names = Factory < T >::get_list();
00832 
00833                 for (size_t i = 0; i < item_names.size(); i++) {
00834                         T *item = Factory < T >::get(item_names[i]);
00835                         printf("%s :  %s\n", item->get_name().c_str(),item->get_desc().c_str());
00836                         TypeDict td = item->get_param_types();
00837                         td.dump();
00838                 }
00839         }

template<class T>
map<string, vector<string> > dump_factory_list  ) 
 

Definition at line 841 of file emobject.h.

References EMAN::TypeDict::get_desc(), EMAN::TypeDict::get_type(), EMAN::TypeDict::keys(), and EMAN::TypeDict::size().

00842         {
00843                 vector < string > item_names = Factory < T >::get_list();
00844                 map<string, vector<string> >    factory_list;
00845 
00846                 typename vector<string>::const_iterator p;
00847                 for(p = item_names.begin(); p !=item_names.end(); ++p) {
00848                         T *item = Factory<T>::get(*p);
00849 
00850                         string name = item->get_name();
00851 
00852                         vector<string> content;
00853                         content.push_back(item->get_desc());
00854                         TypeDict td = item->get_param_types();
00855                         vector<string> keys = td.keys();
00856                         for(unsigned int i=0; i<td.size(); ++i) {
00857                                 content.push_back(keys[i]);
00858                                 content.push_back( td.get_type(keys[i]) );
00859                                 content.push_back( td.get_desc(keys[i]) );
00860                         }
00861                         factory_list[name] = content;
00862                 }
00863 
00864                 return factory_list;
00865         }

bool EMAN::operator!= const Dict d1,
const Dict d2
 

Definition at line 1047 of file emobject.cpp.

01048 {
01049         return !(d1 == d2);
01050 }

bool EMAN::operator!= const EMObject e1,
const EMObject e2
 

Definition at line 896 of file emobject.cpp.

00897 {
00898         return !(e1 == e2);
00899 }

bool EMAN::operator== const Dict d1,
const Dict d2
 

Definition at line 1041 of file emobject.cpp.

References EMAN::Dict::dict.

01042 {
01043         // Just make use of map's version of operator==
01044         return (d1.dict == d2.dict);
01045 }

bool EMAN::operator== const EMObject e1,
const EMObject e2
 

Definition at line 796 of file emobject.cpp.

References EMAN::EMObject::b, EMAN::EMObject::d, EMAN::EMObject::emdata, EMAN::EMObject::f, EMAN::EMObject::farray, EMAN::EMObject::fp, EMAN::EMObject::iarray, EMAN::EMObject::ip, EMAN::EMObject::n, EMAN::EMObject::str, EMAN::EMObject::strarray, EMAN::EMObject::transformarray, EMAN::EMObject::type, EMAN::EMObject::ui, EMAN::EMObject::vp, and EMAN::EMObject::xydata.

00797 {
00798 
00799         if (e1.type != e2.type) {
00800                 return false;
00801         }
00802 
00803         switch (e1.type) {
00804         case  EMObject::BOOL:
00805                 return (e1.b == e2.b);
00806         break;
00807         case  EMObject::INT:
00808                 return (e1.n == e2.n);
00809         break;
00810         case  EMObject::UNSIGNEDINT:
00811                 return (e1.ui == e2.ui);
00812         break;
00813         case  EMObject::FLOAT:
00814                 return (e1.f == e2.f);
00815         break;
00816         case  EMObject::DOUBLE:
00817                 return (e1.d == e2.d);
00818         break;
00819         case EMObject::CTF:
00820         case  EMObject::STRING:
00821                 return (e1.str == e2.str);
00822         break;
00823         case  EMObject::FLOAT_POINTER:
00824                 return (e1.fp == e2.fp);
00825         break;
00826         case  EMObject::INT_POINTER:
00827                 return (e1.ip == e2.ip);
00828         break;
00829         case  EMObject::VOID_POINTER:
00830                 return (e1.vp == e2.vp);
00831         break;
00832         case  EMObject::EMDATA:
00833                 return (e1.emdata == e2.emdata);
00834         break;
00835         case  EMObject::XYDATA:
00836                 return (e1.xydata == e2.xydata);
00837         break;
00838         case  EMObject::TRANSFORM:
00839         case  EMObject::FLOATARRAY:
00840                 if (e1.farray.size() == e2.farray.size()) {
00841                         for (size_t i = 0; i < e1.farray.size(); i++) {
00842                                 if (e1.farray[i] != e2.farray[i]) {
00843                                         return false;
00844                                 }
00845                         }
00846                         return true;
00847                 }
00848                 else {
00849                         return false;
00850                 }
00851         break;
00852         case  EMObject::INTARRAY:
00853                 if (e1.iarray.size() == e2.iarray.size()) {
00854                         for (size_t i = 0; i < e1.iarray.size(); i++) {
00855                                 if (e1.iarray[i] != e2.iarray[i]) {
00856                                         return false;
00857                                 }
00858                         }
00859                         return true;
00860                 }
00861         break;
00862         case  EMObject::STRINGARRAY:
00863                 if (e1.strarray.size() == e2.strarray.size()) {
00864                         for (size_t i = 0; i < e1.strarray.size(); i++) {
00865                                 if (e1.strarray[i] != e2.strarray[i]) {
00866                                         return false;
00867                                 }
00868                         }
00869                         return true;
00870                 }
00871                 else {
00872                         return false;
00873                 }
00874         break;
00875         case EMObject::TRANSFORMARRAY:
00876                 if (e1.transformarray.size() == e2.transformarray.size()) {
00877                         for (size_t i = 0; i < e1.transformarray.size(); i++) {
00878                                 if (e1.transformarray[i] != e2.transformarray[i]) {
00879                                         return false;
00880                                 }
00881                         }
00882                 }
00883         break;
00884         case  EMObject::UNKNOWN:
00885                 // UNKNOWN really means "no type" and if two objects both have
00886                 // type UNKNOWN they really are the same
00887                 return (e1.type == e2.type);
00888         break;
00889         default:
00890                 return false;
00891         break;
00892         }
00893         return false;
00894 }


Generated on Tue Jul 12 13:49:25 2011 for EMAN2 by  doxygen 1.3.9.1