Bigstock/Java

@// This is a rythm template
@// the args are the standard wikiTask arguments
@import org.sidif.triple.TripleQuery
@import org.sidif.triple.Triple
@import com.alibaba.fastjson.JSON
@args() {
  String title 
  String logo
  org.sidif.wiki.WikiTask wikiTask
  org.sidif.triple.TripleStore tripleStore
}


@def static {

  /**
   * Base class
   */
  static abstract class TopicBase {
    // each Topic has a pageid - for non subobject thats the pagename
    public String pageid;

    /**
     * get a WikiSon version of the given name value
     * 
     * @param name
     * @param value
     * @return - the string representation
     */
    public String toWikiSon(String name, String value) {
      String result = "<!-- " + name + " is null-->\n";
      if (value != null)
        result = "|" + name + "=" + value + "\n";
      return result;
    }

    /**
     * get the SiDIF representation of the given property
     * 
     * @param name - the name of the property
     * @param value - the value of the property
     * @param type - the type of the property
     * @return - the SiDIF Sting representation of the property
     */
    public static String propertySiDIF(String name, String value, String type) {
      // default is a comment line which can be filled by uncommenting
      String result = String.format("# is is %s of it\n",name);;
      // if the value is not empty
      if ((value != null) && (!("".equals(value.trim())))) {
        // do we need to quote the result?
        String quote = "";
        // this depends on the Type
        if ("Text".equals(type)) {
          quote = "\"";
        }
        // create a SIDIF Property line like
        // "John" is lastname of it
        // convert double quotes to single quotes - FIXME - should we escape instead?
        value=value.replace("\"","'");
        result = String.format("%s%s%s is %s of it\n",quote,value,quote,name);
      }
      // return the SiDIF property line
      return result;
    }

    /**
     * get me as a String
     * 
     * @param name
     * @param value
     * @return
     */
    public static String propertySiDIF(String name, String value) {
      String result = propertySiDIF(name, value, "Text");
      return result;
    }

    /**
     * check if the given boolean String value is true
     * 
     * @param value
     * @return true if the value is not null and has true/TRUE as it's string
     *         content
     */
    public boolean isTrue(String value) {
      boolean result = false;
      if (value != null && value.toLowerCase().equals("true")) {
        result = true;
      }
      return result;
    }

    /**
     * initialize
     */
    public void init(TripleQuery query) {
    }
  } // TopicBase
 /**
  * Presentation
  * Slide Presentation
  */
  public static class Presentation extends TopicBase {
  
    public String title;
    public String author;
    public String startDate;
    public String file;
    public String lang;

    public String getTitle() { return title; }
    public void setTitle(String pTitle) { title=pTitle; }
    public String getAuthor() { return author; }
    public void setAuthor(String pAuthor) { author=pAuthor; }
    public String getStartDate() { return startDate; }
    public void setStartDate(String pStartDate) { startDate=pStartDate; }
    public String getFile() { return file; }
    public void setFile(String pFile) { file=pFile; }
    public String getLang() { return lang; }
    public void setLang(String pLang) { lang=pLang; }
    /**
     * convert this Presentation to a JSON string
     */
    public String toJson() { return JSON.toJSONString(this); }

    /**
     * convert this Presentation to a WikiSon string
     * @return the WikiSon representation of this Presentation
     */
    public String toWikiSon() {
      String wikison= "{{Presentation\n";
      wikison+=toWikiSon("title",title);
      wikison+=toWikiSon("author",author);
      wikison+=toWikiSon("startDate",startDate);
      wikison+=toWikiSon("file",file);
      wikison+=toWikiSon("lang",lang);
      wikison+="}}\n";
      return wikison;
    }

    /**
     * convert this Presentation to a SiDIF string
     * @return the SiDIF representation of this Presentation
     */
    public String toSiDIF() {
      String siDIF = String.format("%s isA Presentation\n",this.pageid);
      siDIF+=propertySiDIF("title",title,"Text");
      siDIF+=propertySiDIF("author",author,"Text");
      siDIF+=propertySiDIF("startDate",startDate,"Date");
      siDIF+=propertySiDIF("file",file,"Page");
      siDIF+=propertySiDIF("lang",lang,"Text");
      return siDIF;
    }
 
    /**  
     * get the pageid for this topic
     */
    public String getPageid() { return pageid; };

    /**
     * default constructor for Presentation
     */
    public Presentation() {}

    /**
     * construct a Presentation from the given Triple
     * @param query - the TripleQuery to get the triples from
     * @param pPresentationTriple - the triple to construct me from
     */
    public Presentation(TripleQuery query,Triple pPresentationTriple) {
      this(query,pPresentationTriple.getSubject().toString());
    } // constructor

    /**
     * construct a Presentation from the given pageId
     * @param query - the TripleQuery to get the triples from
     * @param pageid - pageid
     */
    public Presentation(TripleQuery query,String pageid) {
      this.pageid=pageid;
      Triple titleTriple=query.selectSingle(pageid,"title",null);
      if (titleTriple==null)
        titleTriple=query.selectSingle(pageid,"Property:Presentation_title",null);
      if (titleTriple!=null) 
        title=titleTriple.getObject().toString();
      Triple authorTriple=query.selectSingle(pageid,"author",null);
      if (authorTriple==null)
        authorTriple=query.selectSingle(pageid,"Property:Presentation_author",null);
      if (authorTriple!=null) 
        author=authorTriple.getObject().toString();
      Triple startDateTriple=query.selectSingle(pageid,"startDate",null);
      if (startDateTriple==null)
        startDateTriple=query.selectSingle(pageid,"Property:Presentation_startDate",null);
      if (startDateTriple!=null) 
        startDate=startDateTriple.getObject().toString();
      Triple fileTriple=query.selectSingle(pageid,"file",null);
      if (fileTriple==null)
        fileTriple=query.selectSingle(pageid,"Property:Presentation_file",null);
      if (fileTriple!=null) 
        file=fileTriple.getObject().toString();
      Triple langTriple=query.selectSingle(pageid,"lang",null);
      if (langTriple==null)
        langTriple=query.selectSingle(pageid,"Property:Presentation_lang",null);
      if (langTriple!=null) 
        lang=langTriple.getObject().toString();
      init(query);
    } // constructor for Presentation
    
    // >>>{user defined topic code}{Presentation}{Presentation}
    // <<<{user defined topic code}{Presentation}{Presentation}
  } // class Presentation
  /**
   * Manager for Presentation
   */
  public static class PresentationManager extends TopicBase {
 
    public String topicName="Presentation";
    public transient List<Presentation> mPresentations=new ArrayList<Presentation>();
    public transient Map<String,Presentation> mPresentationMap=new LinkedHashMap<String,Presentation>();

    /**
     * get my Presentations
     */
    public List<Presentation> getPresentations() {
      List<Presentation> result=this.mPresentations;
      return result;
    }

    /**
     *  add a new Presentation 
     */
    public Presentation add(Presentation pPresentation) {
      mPresentations.add(pPresentation);
      mPresentationMap.put(pPresentation.getPageid(),pPresentation);
      return pPresentation;
    }

    /**
     *  add a new Presentation from the given triple
     */
    public Presentation add(TripleQuery query,Triple pPresentationTriple) {
      Presentation lPresentation=new Presentation(query,pPresentationTriple);
      add(lPresentation);
      return lPresentation;
    }

    // reinitialize my mPresentation map
    public void reinit() {
      mPresentationMap.clear();
      for (Presentation lPresentation:mPresentations) {
        mPresentationMap.put(lPresentation.getPageid(),lPresentation);
      }
    }

    // convert this manager to json format 
    public String toJson() { return JSON.toJSONString(this); }
    
    // get a new manager from the given json string
    public static PresentationManager fromJson(String json) {
      PresentationManager result=JSON.parseObject(json, PresentationManager.class);
      result.reinit();
      return result;
    }

    // default constructor for Presentation Manager
    public PresentationManager() {}

    // add Presentations from the given query
    public void addPresentations(TripleQuery pPresentationQuery,TripleQuery query) {
      if (pPresentationQuery!=null) {
        for (Triple lPresentationTriple:pPresentationQuery.getTriples()) {
          add(query,lPresentationTriple);
        }
      }
    }

    // construct me from the given triple Query query
    public PresentationManager(TripleQuery query) {
      // first query the SiDIF bases triplestore
      TripleQuery lPresentationQuery=query.query(null,"isA","Presentation");
      addPresentations(lPresentationQuery,query);
      // then the SMW triplestore
      lPresentationQuery=query.query(null,"Property:IsA","Presentation");
      addPresentations(lPresentationQuery,query);
      init(query);
    } // constructor for Presentation Manager
    
    // >>>{user defined topicmanager code}{Presentation}{Presentation}
    // <<<{user defined topicmanager code}{Presentation}{Presentation}
  } // class Presentation Manager
 /**
  * Flipchart
  * Representation of the content of a flip chart.
  */
  public static class Flipchart extends TopicBase {
  
    public String title;
    public String text;
    public String size;
    public String picture;
    public String imagelink;
    public String topic;

    public String getTitle() { return title; }
    public void setTitle(String pTitle) { title=pTitle; }
    public String getText() { return text; }
    public void setText(String pText) { text=pText; }
    public String getSize() { return size; }
    public void setSize(String pSize) { size=pSize; }
    public String getPicture() { return picture; }
    public void setPicture(String pPicture) { picture=pPicture; }
    public String getImagelink() { return imagelink; }
    public void setImagelink(String pImagelink) { imagelink=pImagelink; }
    public String getTopic() { return topic; }
    public void setTopic(String pTopic) { topic=pTopic; }
    /**
     * convert this Flipchart to a JSON string
     */
    public String toJson() { return JSON.toJSONString(this); }

    /**
     * convert this Flipchart to a WikiSon string
     * @return the WikiSon representation of this Flipchart
     */
    public String toWikiSon() {
      String wikison= "{{Flipchart\n";
      wikison+=toWikiSon("title",title);
      wikison+=toWikiSon("text",text);
      wikison+=toWikiSon("size",size);
      wikison+=toWikiSon("picture",picture);
      wikison+=toWikiSon("imagelink",imagelink);
      wikison+=toWikiSon("topic",topic);
      wikison+="}}\n";
      return wikison;
    }

    /**
     * convert this Flipchart to a SiDIF string
     * @return the SiDIF representation of this Flipchart
     */
    public String toSiDIF() {
      String siDIF = String.format("%s isA Flipchart\n",this.pageid);
      siDIF+=propertySiDIF("title",title,"Text");
      siDIF+=propertySiDIF("text",text,"Text");
      siDIF+=propertySiDIF("size",size,"Text");
      siDIF+=propertySiDIF("picture",picture,"Text");
      siDIF+=propertySiDIF("imagelink",imagelink,"Text");
      siDIF+=propertySiDIF("topic",topic,"Text");
      return siDIF;
    }
 
    /**  
     * get the pageid for this topic
     */
    public String getPageid() { return pageid; };

    /**
     * default constructor for Flipchart
     */
    public Flipchart() {}

    /**
     * construct a Flipchart from the given Triple
     * @param query - the TripleQuery to get the triples from
     * @param pFlipchartTriple - the triple to construct me from
     */
    public Flipchart(TripleQuery query,Triple pFlipchartTriple) {
      this(query,pFlipchartTriple.getSubject().toString());
    } // constructor

    /**
     * construct a Flipchart from the given pageId
     * @param query - the TripleQuery to get the triples from
     * @param pageid - pageid
     */
    public Flipchart(TripleQuery query,String pageid) {
      this.pageid=pageid;
      Triple titleTriple=query.selectSingle(pageid,"title",null);
      if (titleTriple==null)
        titleTriple=query.selectSingle(pageid,"Property:Flipchart_title",null);
      if (titleTriple!=null) 
        title=titleTriple.getObject().toString();
      Triple textTriple=query.selectSingle(pageid,"text",null);
      if (textTriple==null)
        textTriple=query.selectSingle(pageid,"Property:Flipchart_text",null);
      if (textTriple!=null) 
        text=textTriple.getObject().toString();
      Triple sizeTriple=query.selectSingle(pageid,"size",null);
      if (sizeTriple==null)
        sizeTriple=query.selectSingle(pageid,"Property:Flipchart_size",null);
      if (sizeTriple!=null) 
        size=sizeTriple.getObject().toString();
      Triple pictureTriple=query.selectSingle(pageid,"picture",null);
      if (pictureTriple==null)
        pictureTriple=query.selectSingle(pageid,"Property:Flipchart_picture",null);
      if (pictureTriple!=null) 
        picture=pictureTriple.getObject().toString();
      Triple imagelinkTriple=query.selectSingle(pageid,"imagelink",null);
      if (imagelinkTriple==null)
        imagelinkTriple=query.selectSingle(pageid,"Property:Flipchart_imagelink",null);
      if (imagelinkTriple!=null) 
        imagelink=imagelinkTriple.getObject().toString();
      Triple topicTriple=query.selectSingle(pageid,"topic",null);
      if (topicTriple==null)
        topicTriple=query.selectSingle(pageid,"Property:Flipchart_topic",null);
      if (topicTriple!=null) 
        topic=topicTriple.getObject().toString();
      init(query);
    } // constructor for Flipchart
    
    // >>>{user defined topic code}{Flipchart}{Flipchart}
    // <<<{user defined topic code}{Flipchart}{Flipchart}
  } // class Flipchart
  /**
   * Manager for Flipchart
   */
  public static class FlipchartManager extends TopicBase {
 
    public String topicName="Flipchart";
    public transient List<Flipchart> mFlipcharts=new ArrayList<Flipchart>();
    public transient Map<String,Flipchart> mFlipchartMap=new LinkedHashMap<String,Flipchart>();

    /**
     * get my Flipcharts
     */
    public List<Flipchart> getFlipcharts() {
      List<Flipchart> result=this.mFlipcharts;
      return result;
    }

    /**
     *  add a new Flipchart 
     */
    public Flipchart add(Flipchart pFlipchart) {
      mFlipcharts.add(pFlipchart);
      mFlipchartMap.put(pFlipchart.getPageid(),pFlipchart);
      return pFlipchart;
    }

    /**
     *  add a new Flipchart from the given triple
     */
    public Flipchart add(TripleQuery query,Triple pFlipchartTriple) {
      Flipchart lFlipchart=new Flipchart(query,pFlipchartTriple);
      add(lFlipchart);
      return lFlipchart;
    }

    // reinitialize my mFlipchart map
    public void reinit() {
      mFlipchartMap.clear();
      for (Flipchart lFlipchart:mFlipcharts) {
        mFlipchartMap.put(lFlipchart.getPageid(),lFlipchart);
      }
    }

    // convert this manager to json format 
    public String toJson() { return JSON.toJSONString(this); }
    
    // get a new manager from the given json string
    public static FlipchartManager fromJson(String json) {
      FlipchartManager result=JSON.parseObject(json, FlipchartManager.class);
      result.reinit();
      return result;
    }

    // default constructor for Flipchart Manager
    public FlipchartManager() {}

    // add Flipcharts from the given query
    public void addFlipcharts(TripleQuery pFlipchartQuery,TripleQuery query) {
      if (pFlipchartQuery!=null) {
        for (Triple lFlipchartTriple:pFlipchartQuery.getTriples()) {
          add(query,lFlipchartTriple);
        }
      }
    }

    // construct me from the given triple Query query
    public FlipchartManager(TripleQuery query) {
      // first query the SiDIF bases triplestore
      TripleQuery lFlipchartQuery=query.query(null,"isA","Flipchart");
      addFlipcharts(lFlipchartQuery,query);
      // then the SMW triplestore
      lFlipchartQuery=query.query(null,"Property:IsA","Flipchart");
      addFlipcharts(lFlipchartQuery,query);
      init(query);
    } // constructor for Flipchart Manager
    
    // >>>{user defined topicmanager code}{Flipchart}{Flipchart}
    // <<<{user defined topicmanager code}{Flipchart}{Flipchart}
  } // class Flipchart Manager
 /**
  * Bigstock
  * A photo from http://www.bigstockphoto.com/de/
  */
  public static class Bigstock extends TopicBase {
  
    public String id;
    public String file;

    public String getId() { return id; }
    public void setId(String pId) { id=pId; }
    public String getFile() { return file; }
    public void setFile(String pFile) { file=pFile; }
    /**
     * convert this Bigstock to a JSON string
     */
    public String toJson() { return JSON.toJSONString(this); }

    /**
     * convert this Bigstock to a WikiSon string
     * @return the WikiSon representation of this Bigstock
     */
    public String toWikiSon() {
      String wikison= "{{Bigstock\n";
      wikison+=toWikiSon("id",id);
      wikison+=toWikiSon("file",file);
      wikison+="}}\n";
      return wikison;
    }

    /**
     * convert this Bigstock to a SiDIF string
     * @return the SiDIF representation of this Bigstock
     */
    public String toSiDIF() {
      String siDIF = String.format("%s isA Bigstock\n",this.pageid);
      siDIF+=propertySiDIF("id",id,"Text");
      siDIF+=propertySiDIF("file",file,"Page");
      return siDIF;
    }
 
    /**  
     * get the pageid for this topic
     */
    public String getPageid() { return pageid; };

    /**
     * default constructor for Bigstock
     */
    public Bigstock() {}

    /**
     * construct a Bigstock from the given Triple
     * @param query - the TripleQuery to get the triples from
     * @param pBigstockTriple - the triple to construct me from
     */
    public Bigstock(TripleQuery query,Triple pBigstockTriple) {
      this(query,pBigstockTriple.getSubject().toString());
    } // constructor

    /**
     * construct a Bigstock from the given pageId
     * @param query - the TripleQuery to get the triples from
     * @param pageid - pageid
     */
    public Bigstock(TripleQuery query,String pageid) {
      this.pageid=pageid;
      Triple idTriple=query.selectSingle(pageid,"id",null);
      if (idTriple==null)
        idTriple=query.selectSingle(pageid,"Property:Bigstock_id",null);
      if (idTriple!=null) 
        id=idTriple.getObject().toString();
      Triple fileTriple=query.selectSingle(pageid,"file",null);
      if (fileTriple==null)
        fileTriple=query.selectSingle(pageid,"Property:Bigstock_file",null);
      if (fileTriple!=null) 
        file=fileTriple.getObject().toString();
      init(query);
    } // constructor for Bigstock
    
    // >>>{user defined topic code}{Bigstock}{Bigstock}
    // <<<{user defined topic code}{Bigstock}{Bigstock}
  } // class Bigstock
  /**
   * Manager for Bigstock
   */
  public static class BigstockManager extends TopicBase {
 
    public String topicName="Bigstock";
    public transient List<Bigstock> mBigstocks=new ArrayList<Bigstock>();
    public transient Map<String,Bigstock> mBigstockMap=new LinkedHashMap<String,Bigstock>();

    /**
     * get my BigstockPhotos
     */
    public List<Bigstock> getBigstockPhotos() {
      List<Bigstock> result=this.mBigstocks;
      return result;
    }

    /**
     *  add a new Bigstock 
     */
    public Bigstock add(Bigstock pBigstock) {
      mBigstocks.add(pBigstock);
      mBigstockMap.put(pBigstock.getPageid(),pBigstock);
      return pBigstock;
    }

    /**
     *  add a new Bigstock from the given triple
     */
    public Bigstock add(TripleQuery query,Triple pBigstockTriple) {
      Bigstock lBigstock=new Bigstock(query,pBigstockTriple);
      add(lBigstock);
      return lBigstock;
    }

    // reinitialize my mBigstock map
    public void reinit() {
      mBigstockMap.clear();
      for (Bigstock lBigstock:mBigstocks) {
        mBigstockMap.put(lBigstock.getPageid(),lBigstock);
      }
    }

    // convert this manager to json format 
    public String toJson() { return JSON.toJSONString(this); }
    
    // get a new manager from the given json string
    public static BigstockManager fromJson(String json) {
      BigstockManager result=JSON.parseObject(json, BigstockManager.class);
      result.reinit();
      return result;
    }

    // default constructor for Bigstock Manager
    public BigstockManager() {}

    // add BigstockPhotos from the given query
    public void addBigstockPhotos(TripleQuery pBigstockQuery,TripleQuery query) {
      if (pBigstockQuery!=null) {
        for (Triple lBigstockTriple:pBigstockQuery.getTriples()) {
          add(query,lBigstockTriple);
        }
      }
    }

    // construct me from the given triple Query query
    public BigstockManager(TripleQuery query) {
      // first query the SiDIF bases triplestore
      TripleQuery lBigstockQuery=query.query(null,"isA","Bigstock");
      addBigstockPhotos(lBigstockQuery,query);
      // then the SMW triplestore
      lBigstockQuery=query.query(null,"Property:IsA","Bigstock");
      addBigstockPhotos(lBigstockQuery,query);
      init(query);
    } // constructor for Bigstock Manager
    
    // >>>{user defined topicmanager code}{Bigstock}{Bigstock}
    // <<<{user defined topicmanager code}{Bigstock}{Bigstock}
  } // class Bigstock Manager
 /**
  * Icon
  * An icon is a pictogram that is a symbol for some Topic
  */
  public static class Icon extends TopicBase {
  
    public String name;
    public String style;
    public String size;

    public String getName() { return name; }
    public void setName(String pName) { name=pName; }
    public String getStyle() { return style; }
    public void setStyle(String pStyle) { style=pStyle; }
    public String getSize() { return size; }
    public void setSize(String pSize) { size=pSize; }
    /**
     * convert this Icon to a JSON string
     */
    public String toJson() { return JSON.toJSONString(this); }

    /**
     * convert this Icon to a WikiSon string
     * @return the WikiSon representation of this Icon
     */
    public String toWikiSon() {
      String wikison= "{{Icon\n";
      wikison+=toWikiSon("name",name);
      wikison+=toWikiSon("style",style);
      wikison+=toWikiSon("size",size);
      wikison+="}}\n";
      return wikison;
    }

    /**
     * convert this Icon to a SiDIF string
     * @return the SiDIF representation of this Icon
     */
    public String toSiDIF() {
      String siDIF = String.format("%s isA Icon\n",this.pageid);
      siDIF+=propertySiDIF("name",name,"Text");
      siDIF+=propertySiDIF("style",style,"Text");
      siDIF+=propertySiDIF("size",size,"Number");
      return siDIF;
    }
 
    /**  
     * get the pageid for this topic
     */
    public String getPageid() { return pageid; };

    /**
     * default constructor for Icon
     */
    public Icon() {}

    /**
     * construct a Icon from the given Triple
     * @param query - the TripleQuery to get the triples from
     * @param pIconTriple - the triple to construct me from
     */
    public Icon(TripleQuery query,Triple pIconTriple) {
      this(query,pIconTriple.getSubject().toString());
    } // constructor

    /**
     * construct a Icon from the given pageId
     * @param query - the TripleQuery to get the triples from
     * @param pageid - pageid
     */
    public Icon(TripleQuery query,String pageid) {
      this.pageid=pageid;
      Triple nameTriple=query.selectSingle(pageid,"name",null);
      if (nameTriple==null)
        nameTriple=query.selectSingle(pageid,"Property:Icon_name",null);
      if (nameTriple!=null) 
        name=nameTriple.getObject().toString();
      Triple styleTriple=query.selectSingle(pageid,"style",null);
      if (styleTriple==null)
        styleTriple=query.selectSingle(pageid,"Property:Icon_style",null);
      if (styleTriple!=null) 
        style=styleTriple.getObject().toString();
      Triple sizeTriple=query.selectSingle(pageid,"size",null);
      if (sizeTriple==null)
        sizeTriple=query.selectSingle(pageid,"Property:Icon_size",null);
      if (sizeTriple!=null) 
        size=sizeTriple.getObject().toString();
      init(query);
    } // constructor for Icon
    
    // >>>{user defined topic code}{Icon}{Icon}
    // <<<{user defined topic code}{Icon}{Icon}
  } // class Icon
  /**
   * Manager for Icon
   */
  public static class IconManager extends TopicBase {
 
    public String topicName="Icon";
    public transient List<Icon> mIcons=new ArrayList<Icon>();
    public transient Map<String,Icon> mIconMap=new LinkedHashMap<String,Icon>();

    /**
     * get my Icons
     */
    public List<Icon> getIcons() {
      List<Icon> result=this.mIcons;
      return result;
    }

    /**
     *  add a new Icon 
     */
    public Icon add(Icon pIcon) {
      mIcons.add(pIcon);
      mIconMap.put(pIcon.getPageid(),pIcon);
      return pIcon;
    }

    /**
     *  add a new Icon from the given triple
     */
    public Icon add(TripleQuery query,Triple pIconTriple) {
      Icon lIcon=new Icon(query,pIconTriple);
      add(lIcon);
      return lIcon;
    }

    // reinitialize my mIcon map
    public void reinit() {
      mIconMap.clear();
      for (Icon lIcon:mIcons) {
        mIconMap.put(lIcon.getPageid(),lIcon);
      }
    }

    // convert this manager to json format 
    public String toJson() { return JSON.toJSONString(this); }
    
    // get a new manager from the given json string
    public static IconManager fromJson(String json) {
      IconManager result=JSON.parseObject(json, IconManager.class);
      result.reinit();
      return result;
    }

    // default constructor for Icon Manager
    public IconManager() {}

    // add Icons from the given query
    public void addIcons(TripleQuery pIconQuery,TripleQuery query) {
      if (pIconQuery!=null) {
        for (Triple lIconTriple:pIconQuery.getTriples()) {
          add(query,lIconTriple);
        }
      }
    }

    // construct me from the given triple Query query
    public IconManager(TripleQuery query) {
      // first query the SiDIF bases triplestore
      TripleQuery lIconQuery=query.query(null,"isA","Icon");
      addIcons(lIconQuery,query);
      // then the SMW triplestore
      lIconQuery=query.query(null,"Property:IsA","Icon");
      addIcons(lIconQuery,query);
      init(query);
    } // constructor for Icon Manager
    
    // >>>{user defined topicmanager code}{Icon}{Icon}
    // <<<{user defined topicmanager code}{Icon}{Icon}
  } // class Icon Manager
 /**
  * Image
  * I am an image
  */
  public static class Image extends TopicBase {
  
    public String name;
    public String title;
    public String topic;

    public String getName() { return name; }
    public void setName(String pName) { name=pName; }
    public String getTitle() { return title; }
    public void setTitle(String pTitle) { title=pTitle; }
    public String getTopic() { return topic; }
    public void setTopic(String pTopic) { topic=pTopic; }
    /**
     * convert this Image to a JSON string
     */
    public String toJson() { return JSON.toJSONString(this); }

    /**
     * convert this Image to a WikiSon string
     * @return the WikiSon representation of this Image
     */
    public String toWikiSon() {
      String wikison= "{{Image\n";
      wikison+=toWikiSon("name",name);
      wikison+=toWikiSon("title",title);
      wikison+=toWikiSon("topic",topic);
      wikison+="}}\n";
      return wikison;
    }

    /**
     * convert this Image to a SiDIF string
     * @return the SiDIF representation of this Image
     */
    public String toSiDIF() {
      String siDIF = String.format("%s isA Image\n",this.pageid);
      siDIF+=propertySiDIF("name",name,"Text");
      siDIF+=propertySiDIF("title",title,"Text");
      siDIF+=propertySiDIF("topic",topic,"Text");
      return siDIF;
    }
 
    /**  
     * get the pageid for this topic
     */
    public String getPageid() { return pageid; };

    /**
     * default constructor for Image
     */
    public Image() {}

    /**
     * construct a Image from the given Triple
     * @param query - the TripleQuery to get the triples from
     * @param pImageTriple - the triple to construct me from
     */
    public Image(TripleQuery query,Triple pImageTriple) {
      this(query,pImageTriple.getSubject().toString());
    } // constructor

    /**
     * construct a Image from the given pageId
     * @param query - the TripleQuery to get the triples from
     * @param pageid - pageid
     */
    public Image(TripleQuery query,String pageid) {
      this.pageid=pageid;
      Triple nameTriple=query.selectSingle(pageid,"name",null);
      if (nameTriple==null)
        nameTriple=query.selectSingle(pageid,"Property:Image_name",null);
      if (nameTriple!=null) 
        name=nameTriple.getObject().toString();
      Triple titleTriple=query.selectSingle(pageid,"title",null);
      if (titleTriple==null)
        titleTriple=query.selectSingle(pageid,"Property:Image_title",null);
      if (titleTriple!=null) 
        title=titleTriple.getObject().toString();
      Triple topicTriple=query.selectSingle(pageid,"topic",null);
      if (topicTriple==null)
        topicTriple=query.selectSingle(pageid,"Property:Image_topic",null);
      if (topicTriple!=null) 
        topic=topicTriple.getObject().toString();
      init(query);
    } // constructor for Image
    
    // >>>{user defined topic code}{Image}{Image}
    // <<<{user defined topic code}{Image}{Image}
  } // class Image
  /**
   * Manager for Image
   */
  public static class ImageManager extends TopicBase {
 
    public String topicName="Image";
    public transient List<Image> mImages=new ArrayList<Image>();
    public transient Map<String,Image> mImageMap=new LinkedHashMap<String,Image>();

    /**
     * get my Images
     */
    public List<Image> getImages() {
      List<Image> result=this.mImages;
      return result;
    }

    /**
     *  add a new Image 
     */
    public Image add(Image pImage) {
      mImages.add(pImage);
      mImageMap.put(pImage.getPageid(),pImage);
      return pImage;
    }

    /**
     *  add a new Image from the given triple
     */
    public Image add(TripleQuery query,Triple pImageTriple) {
      Image lImage=new Image(query,pImageTriple);
      add(lImage);
      return lImage;
    }

    // reinitialize my mImage map
    public void reinit() {
      mImageMap.clear();
      for (Image lImage:mImages) {
        mImageMap.put(lImage.getPageid(),lImage);
      }
    }

    // convert this manager to json format 
    public String toJson() { return JSON.toJSONString(this); }
    
    // get a new manager from the given json string
    public static ImageManager fromJson(String json) {
      ImageManager result=JSON.parseObject(json, ImageManager.class);
      result.reinit();
      return result;
    }

    // default constructor for Image Manager
    public ImageManager() {}

    // add Images from the given query
    public void addImages(TripleQuery pImageQuery,TripleQuery query) {
      if (pImageQuery!=null) {
        for (Triple lImageTriple:pImageQuery.getTriples()) {
          add(query,lImageTriple);
        }
      }
    }

    // construct me from the given triple Query query
    public ImageManager(TripleQuery query) {
      // first query the SiDIF bases triplestore
      TripleQuery lImageQuery=query.query(null,"isA","Image");
      addImages(lImageQuery,query);
      // then the SMW triplestore
      lImageQuery=query.query(null,"Property:IsA","Image");
      addImages(lImageQuery,query);
      init(query);
    } // constructor for Image Manager
    
    // >>>{user defined topicmanager code}{Image}{Image}
    // <<<{user defined topicmanager code}{Image}{Image}
  } // class Image Manager
 /**
  * PageOrder
  * A list of pages that have the order as per form editing
  */
  public static class PageOrder extends TopicBase {
  
    public String page;

    public String getPage() { return page; }
    public void setPage(String pPage) { page=pPage; }
    /**
     * convert this PageOrder to a JSON string
     */
    public String toJson() { return JSON.toJSONString(this); }

    /**
     * convert this PageOrder to a WikiSon string
     * @return the WikiSon representation of this PageOrder
     */
    public String toWikiSon() {
      String wikison= "{{PageOrder\n";
      wikison+=toWikiSon("page",page);
      wikison+="}}\n";
      return wikison;
    }

    /**
     * convert this PageOrder to a SiDIF string
     * @return the SiDIF representation of this PageOrder
     */
    public String toSiDIF() {
      String siDIF = String.format("%s isA PageOrder\n",this.pageid);
      siDIF+=propertySiDIF("page",page,"Page");
      return siDIF;
    }
 
    /**  
     * get the pageid for this topic
     */
    public String getPageid() { return pageid; };

    /**
     * default constructor for PageOrder
     */
    public PageOrder() {}

    /**
     * construct a PageOrder from the given Triple
     * @param query - the TripleQuery to get the triples from
     * @param pPageOrderTriple - the triple to construct me from
     */
    public PageOrder(TripleQuery query,Triple pPageOrderTriple) {
      this(query,pPageOrderTriple.getSubject().toString());
    } // constructor

    /**
     * construct a PageOrder from the given pageId
     * @param query - the TripleQuery to get the triples from
     * @param pageid - pageid
     */
    public PageOrder(TripleQuery query,String pageid) {
      this.pageid=pageid;
      Triple pageTriple=query.selectSingle(pageid,"page",null);
      if (pageTriple==null)
        pageTriple=query.selectSingle(pageid,"Property:PageOrder_page",null);
      if (pageTriple!=null) 
        page=pageTriple.getObject().toString();
      init(query);
    } // constructor for PageOrder
    
    // >>>{user defined topic code}{PageOrder}{PageOrder}
    // <<<{user defined topic code}{PageOrder}{PageOrder}
  } // class PageOrder
  /**
   * Manager for PageOrder
   */
  public static class PageOrderManager extends TopicBase {
 
    public String topicName="PageOrder";
    public transient List<PageOrder> mPageOrders=new ArrayList<PageOrder>();
    public transient Map<String,PageOrder> mPageOrderMap=new LinkedHashMap<String,PageOrder>();

    /**
     * get my PageOrders
     */
    public List<PageOrder> getPageOrders() {
      List<PageOrder> result=this.mPageOrders;
      return result;
    }

    /**
     *  add a new PageOrder 
     */
    public PageOrder add(PageOrder pPageOrder) {
      mPageOrders.add(pPageOrder);
      mPageOrderMap.put(pPageOrder.getPageid(),pPageOrder);
      return pPageOrder;
    }

    /**
     *  add a new PageOrder from the given triple
     */
    public PageOrder add(TripleQuery query,Triple pPageOrderTriple) {
      PageOrder lPageOrder=new PageOrder(query,pPageOrderTriple);
      add(lPageOrder);
      return lPageOrder;
    }

    // reinitialize my mPageOrder map
    public void reinit() {
      mPageOrderMap.clear();
      for (PageOrder lPageOrder:mPageOrders) {
        mPageOrderMap.put(lPageOrder.getPageid(),lPageOrder);
      }
    }

    // convert this manager to json format 
    public String toJson() { return JSON.toJSONString(this); }
    
    // get a new manager from the given json string
    public static PageOrderManager fromJson(String json) {
      PageOrderManager result=JSON.parseObject(json, PageOrderManager.class);
      result.reinit();
      return result;
    }

    // default constructor for PageOrder Manager
    public PageOrderManager() {}

    // add PageOrders from the given query
    public void addPageOrders(TripleQuery pPageOrderQuery,TripleQuery query) {
      if (pPageOrderQuery!=null) {
        for (Triple lPageOrderTriple:pPageOrderQuery.getTriples()) {
          add(query,lPageOrderTriple);
        }
      }
    }

    // construct me from the given triple Query query
    public PageOrderManager(TripleQuery query) {
      // first query the SiDIF bases triplestore
      TripleQuery lPageOrderQuery=query.query(null,"isA","PageOrder");
      addPageOrders(lPageOrderQuery,query);
      // then the SMW triplestore
      lPageOrderQuery=query.query(null,"Property:IsA","PageOrder");
      addPageOrders(lPageOrderQuery,query);
      init(query);
    } // constructor for PageOrder Manager
    
    // >>>{user defined topicmanager code}{PageOrder}{PageOrder}
    // <<<{user defined topicmanager code}{PageOrder}{PageOrder}
  } // class PageOrder Manager
 /**
  * PageSequence
  * A Sequence of pages that might belong to the same category and might have an icon
  */
  public static class PageSequence extends TopicBase {
  
    public String prev;
    public String next;
    public String categoryIcon;
    public String category;

    public String getPrev() { return prev; }
    public void setPrev(String pPrev) { prev=pPrev; }
    public String getNext() { return next; }
    public void setNext(String pNext) { next=pNext; }
    public String getCategoryIcon() { return categoryIcon; }
    public void setCategoryIcon(String pCategoryIcon) { categoryIcon=pCategoryIcon; }
    public String getCategory() { return category; }
    public void setCategory(String pCategory) { category=pCategory; }
    /**
     * convert this PageSequence to a JSON string
     */
    public String toJson() { return JSON.toJSONString(this); }

    /**
     * convert this PageSequence to a WikiSon string
     * @return the WikiSon representation of this PageSequence
     */
    public String toWikiSon() {
      String wikison= "{{PageSequence\n";
      wikison+=toWikiSon("prev",prev);
      wikison+=toWikiSon("next",next);
      wikison+=toWikiSon("categoryIcon",categoryIcon);
      wikison+=toWikiSon("category",category);
      wikison+="}}\n";
      return wikison;
    }

    /**
     * convert this PageSequence to a SiDIF string
     * @return the SiDIF representation of this PageSequence
     */
    public String toSiDIF() {
      String siDIF = String.format("%s isA PageSequence\n",this.pageid);
      siDIF+=propertySiDIF("prev",prev,"Page");
      siDIF+=propertySiDIF("next",next,"Page");
      siDIF+=propertySiDIF("categoryIcon",categoryIcon,"Text");
      siDIF+=propertySiDIF("category",category,"Page");
      return siDIF;
    }
 
    /**  
     * get the pageid for this topic
     */
    public String getPageid() { return pageid; };

    /**
     * default constructor for PageSequence
     */
    public PageSequence() {}

    /**
     * construct a PageSequence from the given Triple
     * @param query - the TripleQuery to get the triples from
     * @param pPageSequenceTriple - the triple to construct me from
     */
    public PageSequence(TripleQuery query,Triple pPageSequenceTriple) {
      this(query,pPageSequenceTriple.getSubject().toString());
    } // constructor

    /**
     * construct a PageSequence from the given pageId
     * @param query - the TripleQuery to get the triples from
     * @param pageid - pageid
     */
    public PageSequence(TripleQuery query,String pageid) {
      this.pageid=pageid;
      Triple prevTriple=query.selectSingle(pageid,"prev",null);
      if (prevTriple==null)
        prevTriple=query.selectSingle(pageid,"Property:PageSequence_prev",null);
      if (prevTriple!=null) 
        prev=prevTriple.getObject().toString();
      Triple nextTriple=query.selectSingle(pageid,"next",null);
      if (nextTriple==null)
        nextTriple=query.selectSingle(pageid,"Property:PageSequence_next",null);
      if (nextTriple!=null) 
        next=nextTriple.getObject().toString();
      Triple categoryIconTriple=query.selectSingle(pageid,"categoryIcon",null);
      if (categoryIconTriple==null)
        categoryIconTriple=query.selectSingle(pageid,"Property:PageSequence_categoryIcon",null);
      if (categoryIconTriple!=null) 
        categoryIcon=categoryIconTriple.getObject().toString();
      Triple categoryTriple=query.selectSingle(pageid,"category",null);
      if (categoryTriple==null)
        categoryTriple=query.selectSingle(pageid,"Property:PageSequence_category",null);
      if (categoryTriple!=null) 
        category=categoryTriple.getObject().toString();
      init(query);
    } // constructor for PageSequence
    
    // >>>{user defined topic code}{PageSequence}{PageSequence}
    // <<<{user defined topic code}{PageSequence}{PageSequence}
  } // class PageSequence
  /**
   * Manager for PageSequence
   */
  public static class PageSequenceManager extends TopicBase {
 
    public String topicName="PageSequence";
    public transient List<PageSequence> mPageSequences=new ArrayList<PageSequence>();
    public transient Map<String,PageSequence> mPageSequenceMap=new LinkedHashMap<String,PageSequence>();

    /**
     * get my PageSequences
     */
    public List<PageSequence> getPageSequences() {
      List<PageSequence> result=this.mPageSequences;
      return result;
    }

    /**
     *  add a new PageSequence 
     */
    public PageSequence add(PageSequence pPageSequence) {
      mPageSequences.add(pPageSequence);
      mPageSequenceMap.put(pPageSequence.getPageid(),pPageSequence);
      return pPageSequence;
    }

    /**
     *  add a new PageSequence from the given triple
     */
    public PageSequence add(TripleQuery query,Triple pPageSequenceTriple) {
      PageSequence lPageSequence=new PageSequence(query,pPageSequenceTriple);
      add(lPageSequence);
      return lPageSequence;
    }

    // reinitialize my mPageSequence map
    public void reinit() {
      mPageSequenceMap.clear();
      for (PageSequence lPageSequence:mPageSequences) {
        mPageSequenceMap.put(lPageSequence.getPageid(),lPageSequence);
      }
    }

    // convert this manager to json format 
    public String toJson() { return JSON.toJSONString(this); }
    
    // get a new manager from the given json string
    public static PageSequenceManager fromJson(String json) {
      PageSequenceManager result=JSON.parseObject(json, PageSequenceManager.class);
      result.reinit();
      return result;
    }

    // default constructor for PageSequence Manager
    public PageSequenceManager() {}

    // add PageSequences from the given query
    public void addPageSequences(TripleQuery pPageSequenceQuery,TripleQuery query) {
      if (pPageSequenceQuery!=null) {
        for (Triple lPageSequenceTriple:pPageSequenceQuery.getTriples()) {
          add(query,lPageSequenceTriple);
        }
      }
    }

    // construct me from the given triple Query query
    public PageSequenceManager(TripleQuery query) {
      // first query the SiDIF bases triplestore
      TripleQuery lPageSequenceQuery=query.query(null,"isA","PageSequence");
      addPageSequences(lPageSequenceQuery,query);
      // then the SMW triplestore
      lPageSequenceQuery=query.query(null,"Property:IsA","PageSequence");
      addPageSequences(lPageSequenceQuery,query);
      init(query);
    } // constructor for PageSequence Manager
    
    // >>>{user defined topicmanager code}{PageSequence}{PageSequence}
    // <<<{user defined topicmanager code}{PageSequence}{PageSequence}
  } // class PageSequence Manager
 /**
  * Slide
  * I am a presentation slide
  */
  public static class Slide extends TopicBase {
  
    public String title;
    public String pageno;
    public String based on;
    public String pages;
    public String prev;
    public String next;
    public String leftContent;
    public String rightContent;
    public String text;
    public String notes;
    public String print;
    public String template;
    public String state;
    public String comment;
    public String presentation;

    public String getTitle() { return title; }
    public void setTitle(String pTitle) { title=pTitle; }
    public String getPageno() { return pageno; }
    public void setPageno(String pPageno) { pageno=pPageno; }
    public String getBased on() { return based on; }
    public void setBased on(String pBased on) { based on=pBased on; }
    public String getPages() { return pages; }
    public void setPages(String pPages) { pages=pPages; }
    public String getPrev() { return prev; }
    public void setPrev(String pPrev) { prev=pPrev; }
    public String getNext() { return next; }
    public void setNext(String pNext) { next=pNext; }
    public String getLeftContent() { return leftContent; }
    public void setLeftContent(String pLeftContent) { leftContent=pLeftContent; }
    public String getRightContent() { return rightContent; }
    public void setRightContent(String pRightContent) { rightContent=pRightContent; }
    public String getText() { return text; }
    public void setText(String pText) { text=pText; }
    public String getNotes() { return notes; }
    public void setNotes(String pNotes) { notes=pNotes; }
    public String getPrint() { return print; }
    public void setPrint(String pPrint) { print=pPrint; }
    public String getTemplate() { return template; }
    public void setTemplate(String pTemplate) { template=pTemplate; }
    public String getState() { return state; }
    public void setState(String pState) { state=pState; }
    public String getComment() { return comment; }
    public void setComment(String pComment) { comment=pComment; }
    public String getPresentation() { return presentation; }
    public void setPresentation(String pPresentation) { presentation=pPresentation; }
    /**
     * convert this Slide to a JSON string
     */
    public String toJson() { return JSON.toJSONString(this); }

    /**
     * convert this Slide to a WikiSon string
     * @return the WikiSon representation of this Slide
     */
    public String toWikiSon() {
      String wikison= "{{Slide\n";
      wikison+=toWikiSon("title",title);
      wikison+=toWikiSon("pageno",pageno);
      wikison+=toWikiSon("based on",based on);
      wikison+=toWikiSon("pages",pages);
      wikison+=toWikiSon("prev",prev);
      wikison+=toWikiSon("next",next);
      wikison+=toWikiSon("leftContent",leftContent);
      wikison+=toWikiSon("rightContent",rightContent);
      wikison+=toWikiSon("text",text);
      wikison+=toWikiSon("notes",notes);
      wikison+=toWikiSon("print",print);
      wikison+=toWikiSon("template",template);
      wikison+=toWikiSon("state",state);
      wikison+=toWikiSon("comment",comment);
      wikison+=toWikiSon("presentation",presentation);
      wikison+="}}\n";
      return wikison;
    }

    /**
     * convert this Slide to a SiDIF string
     * @return the SiDIF representation of this Slide
     */
    public String toSiDIF() {
      String siDIF = String.format("%s isA Slide\n",this.pageid);
      siDIF+=propertySiDIF("title",title,"Text");
      siDIF+=propertySiDIF("pageno",pageno,"Text");
      siDIF+=propertySiDIF("based on",based on,"Page");
      siDIF+=propertySiDIF("pages",pages,"Text");
      siDIF+=propertySiDIF("prev",prev,"Page");
      siDIF+=propertySiDIF("next",next,"Page");
      siDIF+=propertySiDIF("leftContent",leftContent,"Text");
      siDIF+=propertySiDIF("rightContent",rightContent,"Text");
      siDIF+=propertySiDIF("text",text,"Text");
      siDIF+=propertySiDIF("notes",notes,"Text");
      siDIF+=propertySiDIF("print",print,"Text");
      siDIF+=propertySiDIF("template",template,"Text");
      siDIF+=propertySiDIF("state",state,"Text");
      siDIF+=propertySiDIF("comment",comment,"Text");
      siDIF+=propertySiDIF("presentation",presentation,"Page");
      return siDIF;
    }
 
    /**  
     * get the pageid for this topic
     */
    public String getPageid() { return pageid; };

    /**
     * default constructor for Slide
     */
    public Slide() {}

    /**
     * construct a Slide from the given Triple
     * @param query - the TripleQuery to get the triples from
     * @param pSlideTriple - the triple to construct me from
     */
    public Slide(TripleQuery query,Triple pSlideTriple) {
      this(query,pSlideTriple.getSubject().toString());
    } // constructor

    /**
     * construct a Slide from the given pageId
     * @param query - the TripleQuery to get the triples from
     * @param pageid - pageid
     */
    public Slide(TripleQuery query,String pageid) {
      this.pageid=pageid;
      Triple titleTriple=query.selectSingle(pageid,"title",null);
      if (titleTriple==null)
        titleTriple=query.selectSingle(pageid,"Property:Slide_title",null);
      if (titleTriple!=null) 
        title=titleTriple.getObject().toString();
      Triple pagenoTriple=query.selectSingle(pageid,"pageno",null);
      if (pagenoTriple==null)
        pagenoTriple=query.selectSingle(pageid,"Property:Slide_pageno",null);
      if (pagenoTriple!=null) 
        pageno=pagenoTriple.getObject().toString();
      Triple based onTriple=query.selectSingle(pageid,"based on",null);
      if (based onTriple==null)
        based onTriple=query.selectSingle(pageid,"Property:Slide_based on",null);
      if (based onTriple!=null) 
        based on=based onTriple.getObject().toString();
      Triple pagesTriple=query.selectSingle(pageid,"pages",null);
      if (pagesTriple==null)
        pagesTriple=query.selectSingle(pageid,"Property:Slide_pages",null);
      if (pagesTriple!=null) 
        pages=pagesTriple.getObject().toString();
      Triple prevTriple=query.selectSingle(pageid,"prev",null);
      if (prevTriple==null)
        prevTriple=query.selectSingle(pageid,"Property:Slide_prev",null);
      if (prevTriple!=null) 
        prev=prevTriple.getObject().toString();
      Triple nextTriple=query.selectSingle(pageid,"next",null);
      if (nextTriple==null)
        nextTriple=query.selectSingle(pageid,"Property:Slide_next",null);
      if (nextTriple!=null) 
        next=nextTriple.getObject().toString();
      Triple leftContentTriple=query.selectSingle(pageid,"leftContent",null);
      if (leftContentTriple==null)
        leftContentTriple=query.selectSingle(pageid,"Property:Slide_leftContent",null);
      if (leftContentTriple!=null) 
        leftContent=leftContentTriple.getObject().toString();
      Triple rightContentTriple=query.selectSingle(pageid,"rightContent",null);
      if (rightContentTriple==null)
        rightContentTriple=query.selectSingle(pageid,"Property:Slide_rightContent",null);
      if (rightContentTriple!=null) 
        rightContent=rightContentTriple.getObject().toString();
      Triple textTriple=query.selectSingle(pageid,"text",null);
      if (textTriple==null)
        textTriple=query.selectSingle(pageid,"Property:Slide_text",null);
      if (textTriple!=null) 
        text=textTriple.getObject().toString();
      Triple notesTriple=query.selectSingle(pageid,"notes",null);
      if (notesTriple==null)
        notesTriple=query.selectSingle(pageid,"Property:Slide_notes",null);
      if (notesTriple!=null) 
        notes=notesTriple.getObject().toString();
      Triple printTriple=query.selectSingle(pageid,"print",null);
      if (printTriple==null)
        printTriple=query.selectSingle(pageid,"Property:Slide_print",null);
      if (printTriple!=null) 
        print=printTriple.getObject().toString();
      Triple templateTriple=query.selectSingle(pageid,"template",null);
      if (templateTriple==null)
        templateTriple=query.selectSingle(pageid,"Property:Slide_template",null);
      if (templateTriple!=null) 
        template=templateTriple.getObject().toString();
      Triple stateTriple=query.selectSingle(pageid,"state",null);
      if (stateTriple==null)
        stateTriple=query.selectSingle(pageid,"Property:Slide_state",null);
      if (stateTriple!=null) 
        state=stateTriple.getObject().toString();
      Triple commentTriple=query.selectSingle(pageid,"comment",null);
      if (commentTriple==null)
        commentTriple=query.selectSingle(pageid,"Property:Slide_comment",null);
      if (commentTriple!=null) 
        comment=commentTriple.getObject().toString();
      Triple presentationTriple=query.selectSingle(pageid,"presentation",null);
      if (presentationTriple==null)
        presentationTriple=query.selectSingle(pageid,"Property:Slide_presentation",null);
      if (presentationTriple!=null) 
        presentation=presentationTriple.getObject().toString();
      init(query);
    } // constructor for Slide
    
    // >>>{user defined topic code}{Slide}{Slide}
    // <<<{user defined topic code}{Slide}{Slide}
  } // class Slide
  /**
   * Manager for Slide
   */
  public static class SlideManager extends TopicBase {
 
    public String topicName="Slide";
    public transient List<Slide> mSlides=new ArrayList<Slide>();
    public transient Map<String,Slide> mSlideMap=new LinkedHashMap<String,Slide>();

    /**
     * get my Slides
     */
    public List<Slide> getSlides() {
      List<Slide> result=this.mSlides;
      return result;
    }

    /**
     *  add a new Slide 
     */
    public Slide add(Slide pSlide) {
      mSlides.add(pSlide);
      mSlideMap.put(pSlide.getPageid(),pSlide);
      return pSlide;
    }

    /**
     *  add a new Slide from the given triple
     */
    public Slide add(TripleQuery query,Triple pSlideTriple) {
      Slide lSlide=new Slide(query,pSlideTriple);
      add(lSlide);
      return lSlide;
    }

    // reinitialize my mSlide map
    public void reinit() {
      mSlideMap.clear();
      for (Slide lSlide:mSlides) {
        mSlideMap.put(lSlide.getPageid(),lSlide);
      }
    }

    // convert this manager to json format 
    public String toJson() { return JSON.toJSONString(this); }
    
    // get a new manager from the given json string
    public static SlideManager fromJson(String json) {
      SlideManager result=JSON.parseObject(json, SlideManager.class);
      result.reinit();
      return result;
    }

    // default constructor for Slide Manager
    public SlideManager() {}

    // add Slides from the given query
    public void addSlides(TripleQuery pSlideQuery,TripleQuery query) {
      if (pSlideQuery!=null) {
        for (Triple lSlideTriple:pSlideQuery.getTriples()) {
          add(query,lSlideTriple);
        }
      }
    }

    // construct me from the given triple Query query
    public SlideManager(TripleQuery query) {
      // first query the SiDIF bases triplestore
      TripleQuery lSlideQuery=query.query(null,"isA","Slide");
      addSlides(lSlideQuery,query);
      // then the SMW triplestore
      lSlideQuery=query.query(null,"Property:IsA","Slide");
      addSlides(lSlideQuery,query);
      init(query);
    } // constructor for Slide Manager
    
    // >>>{user defined topicmanager code}{Slide}{Slide}
    // <<<{user defined topicmanager code}{Slide}{Slide}
  } // class Slide Manager

}