Properties.hpp

Go to the documentation of this file.

/* ImLib3D
 * Copyright (c) 2001, ULP-IPB Strasbourg.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#ifndef _Properties_hpp
#define _Properties_hpp


#include<sstream>
#include<map>
#include<ImLib3D/XMLTools.hpp>

class ImageProperty : public Streamable
{
public:
    string name;
//      virtual void Write(ImLib3DFile *file,xmlpp::Element *parentNode=NULL,xmlpp::Element *node=NULL) const =0;
//      virtual void Read( ImLib3DFile *file,xmlpp::Element *parentNode=NULL,xmlpp::Element *node=NULL)=0;
    virtual ImageProperty *Duplicate() const=0;
    virtual bool operator==(const ImageProperty &other){return true;}
    bool IsXML();
    virtual ~ImageProperty(){;}
    ImageProperty(const string &_name):name(_name){;}
};


class PropertyXML : public ImageProperty
{
    xmlpp::Document document;
public:
    xmlpp::Element       *RootElement()       {return document.get_root_node();}
    const xmlpp::Element *RootElement() const {return document.get_root_node();}
    virtual void Write(ImLib3DFile *file,xmlpp::Element *parentNode=NULL,xmlpp::Element *node=NULL) const 
    {
        parentNode->import_node(document.get_root_node());
    }
    virtual void Read(ImLib3DFile *file,xmlpp::Element *parentNode=NULL,xmlpp::Element *node=NULL)
    {
        document.create_root_node_by_import(node);
    }
    virtual ImageProperty *Duplicate() const
    {
        PropertyXML *res=new PropertyXML(name);
        res->document.create_root_node_by_import(document.get_root_node());
        return res;
    }
    PropertyXML(const string &_name):ImageProperty(_name){;}
    PropertyXML(const string &_name,const xmlpp::Element *node):
        ImageProperty(_name)
    {
        document.create_root_node_by_import(node);
    }
};


template<class PType>
class TemplatedProperty : public ImageProperty
{
public:
    virtual PType &Get()=0;
    virtual const PType &Get() const =0;
    TemplatedProperty(const string &_name):ImageProperty(_name){;}
};

template<class T> 
inline void 
PropertyWrapPtr_ReadFromString(const string &str,T *p)
{
    istringstream ist(str);
    ist >> *p;
}
template<> 
inline void 
PropertyWrapPtr_ReadFromString<string>(const string &str,string *p)
{
    *p=str;
}


template<class PType>
class PropertyWrapPtr : public TemplatedProperty<PType>
{
    typedef TemplatedProperty<PType> _Base;
public:
    PType *ptr;
    virtual PType &Get(){return *ptr;}
    virtual const PType &Get() const {return *ptr;}
    virtual bool operator==(const ImageProperty &other){return true;}//*ptr==*other.ptr;}
    virtual void Write(ImLib3DFile *file,xmlpp::Element *parentNode=NULL,xmlpp::Element *node=NULL) const 
    {
        node=CreateWriteNode(_Base::name,file,parentNode,node);
        ostringstream ost;
        ost << *ptr;
        node->set_attribute("value",ost.str());
        node->set_attribute("PropertyType","PropertyWrapPtr");
        node->set_attribute("type",TypeName<PType>());
    }

    virtual void Read(ImLib3DFile *file,xmlpp::Element *parentNode=NULL,xmlpp::Element *node=NULL)
    {
        node=CreateReadNode(_Base::name,file,parentNode,node);
        if(!ptr){ptr=new PType();}
        mprintf("PropertyWrapPtr::Read: valueprop:%x\n",node->get_attribute("value" ));
        string value=node->get_attribute("value" )->get_value();
        mprintf("PropertyWrapPtr::Read: value:%s\n",value.c_str());
        PropertyWrapPtr_ReadFromString<PType>(value,ptr);
    }
    virtual ImageProperty *Duplicate() const
    {
        PropertyWrapPtr<PType> *res=new PropertyWrapPtr<PType>(_Base::name);
        res->ptr=new PType();
        *(res->ptr)=*ptr;
        return res;
    }
    virtual ~PropertyWrapPtr(){if(ptr)delete ptr;}
    PropertyWrapPtr(const string &_name,PType *_ptr):TemplatedProperty<PType>(_name),ptr(_ptr){;}
    PropertyWrapPtr(const string &_name):TemplatedProperty<PType>(_name),ptr(NULL){;}
};


class Mask3D;

class Properties : public Streamable
{
    typedef ImageProperty Prop;
    typedef PropertyXML PropXML;
    mutable map<string,Prop *> properties;
public:

    void ClearProperties();

    template<class PropClass>
    void Parse(const string &name)
    {
        map<string,Prop *>::iterator p=properties.find(name);
        if(p==properties.end()){ThrowError("Properties::Parse: could not find property:\"%s\"",name);}
        PropXML *propxml=(PropXML *)((*p).second);
        if(!propxml->IsXML())
        {
            mprintf("WARNING: Properties::Parse: \"%s\" not xml prop. Maybe it has already been parsed?\n",name);
            return;
        }
        properties.erase(p);
        properties[name]=new PropClass(name);
        ImLib3DFile file("","m");
        properties[name]->Read(&file,NULL,propxml->RootElement());
        delete propxml;
    }

    template<class PType>
    void DefaultParse(const string &name) 
    {
        Parse<PropertyWrapPtr<PType> >(name);
    }
    // sets a property
    void       Set(const string &name,const ImageProperty *value)
    {
        map<string,Prop *>::iterator p=properties.find(name);
        if(p!=properties.end())
        {
            delete properties[name];
        }
        properties[name]=value->Duplicate();
    }

    ImageProperty       *Get(const string &name)
    {
        map<string,Prop *>::iterator p=properties.find(name);
        if(p==properties.end()){ThrowError("Properties::Get: could not find property:\"%s\"",name);}
        if((*p).second->IsXML()){ThrowError("Properties::Get: unparsed property \"%s\", you must parse it before accesing it",name);}
        return (*p).second;
    }

    const ImageProperty       *Get(const string &name) const
    {
        map<string,Prop *>::iterator p=properties.find(name);
        if(p==properties.end()){ThrowError("Properties::Get: could not find property:\"%s\"",name);}
        if((*p).second->IsXML()){ThrowError("Properties::Get: unparsed property \"%s\", you must parse it before accesing it",name);}
        return (*p).second;
    }

    template<class PType>
    PType       &GetTemplatedProperty(const string &name)
    {
        return dynamic_cast<TemplatedProperty<PType> *>(Get(name))->Get();
    }

    template<class PType>
    const PType  &GetTemplatedProperty(const string &name,PType dud=PType()) const
    {
        return dynamic_cast<const TemplatedProperty<PType> *>(Get(name))->Get();
    }

    bool Has(const string &propname) const {return properties.find(propname)!=properties.end();}

    void Add(const string &name,const char * str){Add(name,string(str));}

    template<class PType>
    void Add(const string &name,PType* ptr)
    {
        if(properties.find(name)!=properties.end()){delete properties[name];}
        properties[name]=new PropertyWrapPtr<PType>(name,ptr);
    }
    template<class PType>
    void Add(const string &name,PType obj)
    {
        PType *ptr=new PType(obj);
//      *ptr=obj;
        Add(name,ptr);
    }


    void AddUnparsed(const string &name,const PropertyXML &unparsed)
    {
        properties[name]=unparsed.Duplicate();
    }


    void Remove(const string &name);

    Mask3D    *mask;
    Vect3Di   *iCenter;

    void operator=(const Properties &other);
    bool operator==(const Properties &other) const;

    void Read( ImLib3DFile *file,xmlpp::Element *parentNode=NULL,xmlpp::Element *node=NULL);
    void Write(ImLib3DFile *file,xmlpp::Element *parentNode=NULL,xmlpp::Element *node=NULL) const;

    void AddMask(const Size3D &size);

    virtual ~Properties(){ClearProperties();}

    template<class ImageType>
    Properties(ImageType *_image):
        mask(NULL),
        iCenter(NULL)
    {
        ;
    }
};
#endif // _Properties_hpp

---