contentpackage.hh

Go to the documentation of this file.

/************************************************************************

Copyright Rice University, 2006
All rights reserved.

Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, provided that the above copyright notice(s) and this
permission notice appear in all copies of the Software and that both the
above copyright notice(s) and this permission notice appear in supporting
documentation.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY
RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
THIS SOFTWARE.

Except as contained in this notice, the name of a copyright holder shall
not be used in advertising or otherwise to promote the sale, use or other
dealings in this Software without prior written authorization of the
copyright holder.

**************************************************************************/

#ifndef __RVL_TOOLS_NEW_CONTENT_PACKAGE_
#define __RVL_TOOLS_NEW_CONTENT_PACKAGE_

#include "local.hh"
#include "dejavu.hh"

namespace RVL {

  // forward declaration
  template<typename T, typename M>
  class ContentPackage;

  // rewrite of ADP's ContentPackage - now stores only a single 
  // metadata object, which is supposed to be collective
  
  template<typename MetaType>
  size_t getDataSize(MetaType const & md) {
    size_t t = md;
    return t;
  }

  template<class MetaType>
  size_t getMetaSize(MetaType const & md) {
    return sizeof(MetaType);
  }

  template<typename MetaType>
  char * serialize(MetaType const & mt, size_t & len) {
    len = getMetaSize<MetaType>(mt);
    char * cbuf = new char[len];
    memcpy(cbuf, (char *)(&mt), len);
    return cbuf;
  }

  template<typename MetaType>
  MetaType * deserialize(char * cbuf, size_t len) {
    // functional only for data of fixed size and 
    // default construction - test this first
    MetaType * mt = new MetaType;
    if (len < getMetaSize<MetaType>(*mt)) {
      RVLException e;
      e<<"ERROR: deserialize[ContentPackage MetaType]\n";
      e<<"  asserted size of char buf too small to hold\n";
      e<<"  metadata object of this type\n";
      throw e;
    }
    memcpy((char *)mt,cbuf,getMetaSize<MetaType>(*mt));
    return mt;
  }

  template<typename DataType, typename MetaType>
  char * serialize(ContentPackage<DataType,MetaType> const & cp, size_t & len) {
    size_t mlen = 0;
    char * mbuf = serialize<MetaType>(cp.getMetadata(), mlen);
    size_t dlen = getDataSize<MetaType>(cp.getMetadata())*sizeof(DataType);
    len = mlen + dlen;
    char * cbuf = new char[len];
    memcpy(cbuf,mbuf,mlen);
    memcpy(&(cbuf[mlen]),(char *)(cp.getData()),dlen);
    delete [] mbuf;
    return cbuf;
  }

  template<typename DataType, typename MetaType>
  ContentPackage<DataType,MetaType> * deserialize(char * cbuf, size_t len) {
    try {
      MetaType * mt = deserialize<MetaType>(cbuf,len);
      int clen = getMetaSize<MetaType>(*mt) + getDataSize<MetaType>(*mt)*sizeof(DataType);
      if (len != clen) {
    RVLException e;
    e<<"ERROR: deserialize[ContentPackage]\n";
    e<<"  asserted size of char buffer appears to differ from that needed\n";
    e<<"  to store CP object of given type\n";
    e<<"  asserted size of char buffer = "<<len<<"\n";
    e<<"  require buffer size for CP   = "<<clen<<"\n";
    throw e;
      }
      ContentPackage<DataType,MetaType> * cp = new ContentPackage<DataType,MetaType>;
      cp->initialize(*mt);
      delete mt;
      memcpy((char *)(cp->getData()), &(cbuf[getMetaSize<MetaType>(*mt)]),getDataSize<MetaType>(*mt)*sizeof(DataType) );
      return cp;
    }
    catch (RVLException & e) {
      e<<"\ncalled from deserialize[ContentPackage]\n";
      throw e;
    }
  }

  template<class MetaType>
  ostream & writeMeta(MetaType const & md, ostream & e) { 
    e<<md<<"\n"; return e; }

  template<typename DataType,typename MetaType>
  DataType * newData(MetaType & md) {
    return new DataType[getDataSize<MetaType>(md)];
  }

  template<typename DataType,typename MetaType>
  void deleteData(DataType ** d, MetaType ** md) {
    delete [] *d; *d=NULL;
  }

  template<class DataType, class MetaType >
  class ContentPackage: public LocalDataContainer<DataType> {
    
  private:
    
    mutable MetaType * md;
    mutable DataType * d;
    bool own;

  public:    

    ContentPackage(const ContentPackage<DataType,MetaType> & bin)
      : md(NULL), d(NULL), own(bin.own) {
      if (bin.md) {
    md = new MetaType(*(bin.md));
    if (own) {
      //      d = new DataType[getDataSize<MetaType>(*md)];
      d=newData<DataType,MetaType>(*md);
      memcpy(d,bin.d,getDataSize<MetaType>(*md)*sizeof(DataType));
    }
    else {
      d = bin.d;
    }
      }
      //cerr<<"CP copy constr: md = "<<md<<" d = "<<d<<" own = "<<own<<" this = "<<this<<endl;
      //cerr<<"*** metadata:"<<endl;
      //      writeMeta<MetaType>(*md,cerr);
    } 

    ContentPackage() 
      :md(NULL), d(NULL), own(true) {
      //cerr<<"CP main constr: md = "<<md<<" d = "<<d<<" this = "<<this<<endl;
    }

    virtual ~ContentPackage() {
      //cerr<<"CP destr begin, this = "<<this<<"\n";
      //cerr<<"   d = "<<d<<" own = "<<own<<endl;
      //if (d && own) delete [] d; d = NULL;
      if (d && own) deleteData<DataType,MetaType>(&d,&md);
      //cerr<<"  d = "<<d<<endl;
      //cerr<<"*** metadata: md="<<md<<endl;
      //writeMeta<MetaType>(*md,cerr);
      if (md) {
    //cerr<<"  delete md\n";
    delete md; md = NULL;
    //cerr<<"  md = "<<md<<endl;
      }
      //cerr<<"CP destr finish\n";
    }
        
    bool initialize(MetaType const & _md, 
            LocalDataContainer<DataType> * p = NULL,
            size_t start = 0) {
      if (md) return false;
      md = new MetaType(_md);
      //cerr<<"CP::initialize - md = "<<md<<" this = "<<this<<endl;
      //cerr<<"*** metadata:"<<endl;
      //writeMeta<MetaType>(*md,cerr);
      if (p) {
    if (getDataSize<MetaType>(*md) <= p->getSize()-start) {
      d = &((p->getData())[start]);
      own = false;
      return true;
    }
    else {
      //cerr<<"warning: ContentPackage::initialize\n";
      //      cerr<<"attempted to build view of external LDC\n";
      //      cerr<<"of length "<<getDataSize<MetaType>(*md)<<" starting at word "
      //       <<start<<" of LDC of length "<<p->getSize()<<"\n";
      delete md;
      md=NULL;
      return false;
    }
      }
      else {
    //  d = new DataType[getDataSize<MetaType>(*md)];
    d=newData<DataType,MetaType>(*md);
    return true;
      }
    }

    bool isInitialized() const { if (md) return true; return false; }

    ContentPackage<DataType,MetaType> & 
    operator=(ContentPackage<DataType,MetaType> const & src) { 
      if (this != &src) {
    if (*md != *(src.md)) {
      RVLException e;
      e<<"Error: ContentPackage assignment op\n";
      e<<"metadata of this differs from metadata of source\n";
      throw e;
    }
    size_t n = getDataSize<MetaType>(*md);
    if (!d) d = new DataType[n];
    memcpy(d,src.d,n*sizeof(DataType));
      }
      return *this;
    }
    bool operator==(ContentPackage<DataType,MetaType> const & a) const {
      if (this == &a) return true;
      if (*md != *(a.md)) return false;
      if (getSize() != a.getSize()) return false;
      for (size_t i=0;i<getSize();i++) {
    if (getData()[i] != a.getData()[i]) return false;
      }
      return true;
    }
    bool operator!=(ContentPackage<DataType,MetaType> const & a) const { 
      return !operator==(a); 
    }

    bool isCompatible(ContentPackage<DataType,MetaType> const & a) const {
      return (this->getMetadata() == a.getMetadata());
    }

    MetaType & getMetadata() { 
      if (!md) {
    RVLException e;
    e<<"Error: ContentPackage::getMetaData\n";
    e<<"metadata not initialized yet\n";
    throw e;
      }
      return *md;
    }

    MetaType const & getMetadata() const { 
      if (!md) {
    RVLException e;
    e<<"Error: ContentPackage::getMetaData\n";
    e<<"metadata not initialized yet\n";
    throw e;
      }
      return *md;
    }

    size_t getSize() const { 
      if (md) return getDataSize<MetaType>(*md); 
      return 0;
    }

    DataType * getData() {
      if (!d) {
    RVLException e;
    e<<"Error: ContentPackage::getData\n";
    e<<"data not initialized yet\n";
    throw e;
      }
      return d;
    } 
    DataType const * getData() const {
      if (!d) {
    RVLException e;
    e<<"Error: ContentPackage::getData\n";
    e<<"data not initialized yet\n";
    throw e;
      }
      return d;
    } 

    ostream & write(ostream & str) const {
      str<<"ContentPackage LDC, MetaData = \n";
      if (md) {
    writeMeta<MetaType>(*md,str);
      }
      else {
    str<<"(not initialized)\n";
      }
      str<<"  and data array\n";
      for (size_t i=0;i<this->getSize(); i++) {
    str<<"  "<<i<<". ";
    writeMeta<DataType>(d[i],str);
      }
      return str;
    }
  };


  template<typename Source, typename Target>
  void copyCP(Source const & in, Target & out) {
    try {
      size_t n = min(in.getSize(),out.getSize());
      for (size_t i=0;i<n;i++) out.getData()[i]=in.getData()[i];
    }
    catch (RVLException & e) {
      e<<"\ncalled from copyCP\n";
      throw e;
    }
  }

  template<typename DataType, typename MetaType>
  class PackageContainer: 
    public DataContainer {

  protected:

    virtual ContentPackage<DataType,MetaType> 
    & get(bool & more) = 0;
    virtual ContentPackage<DataType,MetaType> const 
    & get(bool & more) const = 0;

    virtual void put() const = 0;

    virtual void reset() const = 0;

  public:

    PackageContainer() {}
    PackageContainer(PackageContainer<DataType,MetaType> const &) {}
    virtual ~PackageContainer() {}
    
    virtual void eval(FunctionObject & f, 
                      std::vector<DataContainer const *> & x) {
      try {
    //  cerr<<"pc: before reset\n";
    //  this->write(cerr);
    this->reset();
    //  cerr<<"pc: after reset\n";
    //  this->write(cerr);
    std::vector<PackageContainer<DataType,MetaType> const *> pcx(x.size());
    for (size_t i=0;i<x.size();i++) {
      if (!(pcx[i] = dynamic_cast<PackageContainer<DataType,MetaType> 
        const *>(x[i]))) {
        RVLException e;
        e<<"Error: PackageContainer::eval(FO)\n";
        e<<"at least one other arg is not a package container.\n";
        for (size_t j=0;j<x.size();j++) {
          e<<"*** arg "<<j<<":\n";
          x[j]->write(e);
        }
        throw e;
      }
      // cannot alias input with output
      if (this == pcx[i]) {
        RVLException e;
        e<<"Error: PackageContainer::eval(FO)\n";
        e<<"input argument "<<i<<" aliased with output\n";
        throw e;
      }
      pcx[i]->reset();
    }
    
    bool more = true;
    std::vector<DataContainer const *> cpx(x.size());

    //  cerr<<"cp: size="<<x.size()<<endl;
    //  cerr<<"cp: more="<<more<<endl;
    while (more) {
      for (size_t i=0;i<x.size();i++) {
        // check for alias
        size_t j=i;
        dejavu<PackageContainer<DataType,MetaType> const>(&j,pcx);
        // if j has not changed value, then this is a non-aliased arg
        if (j==i) { cpx[i]=&(pcx[i]->get(more)); }
        // otherwise we've already seen it
        else { cpx[i] = cpx[j]; }
      }
      //      cerr<<"cp->get\n";
      //      this->write(cerr);
      ContentPackage<DataType,MetaType> & cp = this->get(more);
      //      cerr<<"cp->eval\n";
      cp.eval(f,cpx);
      //      cerr<<"this->put\n";
      this->put();
    }
      }
      catch (RVLException & e) {
    e<<"\ncalled from PackageContainer::eval(FO)\n";
    throw e;
      }
    }
              
    virtual void eval(FunctionObjectConstEval & f, 
                      vector<DataContainer const *> & x) const {
      try {
    this->reset();
    std::vector<PackageContainer<DataType,MetaType> const *> pcx(x.size());
    for (size_t i=0;i<x.size();i++) {
      if (!(pcx[i] = 
        dynamic_cast<PackageContainer<DataType,MetaType> 
        const *>(x[i]))) {
        RVLException e;
        e<<"Error: PackageContainer::eval(FOR)\n";
        e<<"at least one other arg is not a package container.\n";
        throw e;
      }
      pcx[i]->reset();
    }
    bool more = true;
    std::vector<DataContainer const *> cpx(x.size());

    while (more) {
      ContentPackage<DataType,MetaType> const & cp = this->get(more);
      for (size_t i=0;i<x.size();i++) {
        // check for alias with target
        if (this == pcx[i]) {
          cpx[i] = &cp;
        }
        else {
          // check for alias
          size_t j=i;
          dejavu<PackageContainer<DataType,MetaType> const>(&j,pcx);
          // if j has not changed value, then this is a non-aliased arg
          if (j==i) { 
        cpx[i]=&(pcx[i]->get(more)); }
          // otherwise we've already seen it
          else { 
        cpx[i] = cpx[j]; 
          }
        }
      }
      cp.eval(f,cpx);
    }
      }
      catch (RVLException & e) {
    e<<"\ncalled from PackageContainer::eval(FOR)\n";
    throw e;
      }
    }

  };

  template<typename DataType,typename MetaType>
  class PackageContainerFactory: public DataContainerFactory {
  protected:

    virtual PackageContainer<DataType,MetaType> * buildPC() const = 0;
    
  public:

    virtual PackageContainerFactory<DataType,MetaType> * clone() const = 0;

    DataContainer * build() const { return buildPC(); }

    virtual bool compare( DataContainerFactory const & dcf) const {
      PackageContainerFactory<DataType,MetaType> const * ptr = NULL;
      if ((ptr = 
       dynamic_cast< PackageContainerFactory<DataType,MetaType> const * >(&dcf)))
    return true;
      return false;
    }

    virtual bool isCompatible(DataContainer const & dc) const {
      PackageContainer<DataType,MetaType> const * ptr = NULL;
      if ((ptr = 
       dynamic_cast< PackageContainer<DataType,MetaType> const * >(&dc)))
    return true;
      return false;
    }
      
    virtual ostream & write(ostream & str) const {
      str<<"PackageContainerFactory\n";
      return str;
    }    
  };
    
  template<typename Datatype, typename Metatype>
  class SingleDataContainer: public PackageContainer<Datatype,Metatype> {
    
  private:
    
    ContentPackage<Datatype,Metatype> gd;
    mutable int nrep;
    int nrep0;

  protected:

    ContentPackage<Datatype,Metatype> & get(bool & more) {
      nrep--;
      if (nrep<1) more = false; 
      return gd;
    }
    
    ContentPackage<Datatype,Metatype> const & get(bool & more) const {
      nrep--;
      if (nrep<1) more = false; 
      return gd;
    }

    void put() const {}

    void reset() const { nrep=nrep0; }

  public:
    
    SingleDataContainer(int _nrep = 1)
      : PackageContainer<Datatype,Metatype>(), 
    gd(), nrep(_nrep), nrep0(nrep) {}
    
    SingleDataContainer(SingleDataContainer<Datatype,Metatype> const & g)
      : PackageContainer<Datatype,Metatype>(g), gd(g.gd), 
    nrep(g.nrep), nrep0(g.nrep0) {}
    ~SingleDataContainer() {}
    
    void initialize(Metatype const & g) { gd.initialize(g); }
    Metatype const & getMetadata() const {
      if (gd.isInitialized()) return gd.getMetadata();
      RVLException e;
      e<<"Error: SingleDataContainer::getMetadata\n";
      e<<"cannot return reference to internal Metadata, as\n";
      e<<"this is not initialized yet.\n";
      throw e;
    }
    
    ostream & write(ostream & e) const {
      e<<"SingleDataContainer encapsulating ContentPackage object:\n";
      gd.write(e);
      return e;
    }
    
  };  

  template<typename Datatype, typename Metatype>
  class SingleDataContainerFactory: 
    public PackageContainerFactory<Datatype,Metatype> {
  private:
    int nrep;
    Metatype * g;

  protected:
    PackageContainer<Datatype,Metatype> * buildPC() const {
      SingleDataContainer<Datatype,Metatype> * gdc 
    = new SingleDataContainer<Datatype,Metatype>(nrep);
      if (g) {
    gdc->initialize(*g);
    return gdc;
      }
      else {
    RVLException e;
    e<<"Error: SingleDataContainerFactory::buildPC\n";
    e<<"internal Metadata not initialized\n";
    throw e;
      }
    }
    
  public:
    SingleDataContainerFactory(int _nrep=1): nrep(_nrep), g(NULL) {}
    SingleDataContainerFactory
    (SingleDataContainerFactory<Datatype,Metatype> const & f)
      : nrep(f.nrep), g(NULL) { 
      if (f.g) g=new Metatype(*(f.g)); }
    ~SingleDataContainerFactory() { if (g) delete g; }
  
    PackageContainerFactory<Datatype,Metatype> * clone() const {
      if (g) {
    SingleDataContainerFactory<Datatype,Metatype> * f 
      = new SingleDataContainerFactory<Datatype,Metatype>;
    f->initialize(*g);
    return f;
      }
      RVLException e;
      e<<"Error: SingleDataContainerFactory::clone\n";
      e<<"cannot construct copy because not initialized\n";
      throw e;
    }
    void initialize(Metatype const & _g) { g = new Metatype(_g); } 

    bool compare( DataContainerFactory const & dcf) const {
      try {
    if (!g) {
      cerr<<"Warning: SingleDataContainerFactory::compare\n";
      cerr<<"cannot compare uninitialized factory to others\n";
      return false;
    }
    SingleDataContainerFactory<Datatype,Metatype> const * dcfptr = NULL;
    if ((dcfptr = dynamic_cast<SingleDataContainerFactory<Datatype,Metatype> const *>(dcfptr))) {
      if (!(dcfptr->g)) {
        cerr<<"Warning: GridDataContainerFactory::compare\n";
        cerr<<"cannot compare this to uninitialized factory\n";
        return false;
      }
      if ( *g == *(dcfptr->g)) return true;
    }
      }
      catch (RVLException & e) {
    e<<"\ncalled from SingleDataContainerFactory::compare\n";
    throw e;
      }
    }     

    bool isCompatible(DataContainer const & dc) const {
      try {
    if (!g) {
      cerr<<"Warning: SingleDataContainerFactory::isCompatible\n";
      cerr<<"cannot decide compatibility for uninitialized factory\n";
      return false;
    }
    SingleDataContainer<Datatype,Metatype> const * dcptr = NULL;
    if ((dcptr = dynamic_cast<SingleDataContainer<Datatype,Metatype> const *>(&dc))) 
    if (*g == dcptr->getMetadata()) return true;
    return false;
      }
      catch (RVLException & e) {
    e<<"\ncalled from GridDataContainerFactory::isCompatible\n";
    throw e;
      }
    }   
    
    ostream & write(ostream & str) const {
      str<<"SingleDataContainerFactory";
      if (g) {
    str<<" using Metadata:\n";
    g->write(str);
      }
      else {
    str<<" (uninitialized)\n";
      }
      return str;
    }      
  
  };

}

#endif

---