Concept:Topic/Java

java code

<source lang='java' id='javacode'>@// 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 {
   /**
    * initialize
    */
   public void init(TripleQuery query) {
   }
 } // TopicBase
/**
 * Context
 * A Context groups some topics like a Namespace/Package
 */
 public static class Context extends TopicBase {
   public String pageid;
   public String name;

   public String getName() { return name; }
   public void setName(String pName) { name=pName; }
   /**
    * convert this Context to a JSON string
    */
   public String toJson() { return JSON.toJSONString(this); }

   /**  
    * get the pageid for this topic
    */
   public String getPageid() { return pageid; };

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

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

   /**
    * construct a Context from the given pageId
    * @param query - the TripleQuery to get the triples from
    * @param pageid - pageid
    */
   public Context(TripleQuery query,String pageid) {
     this.pageid=pageid;
     Triple nameTriple=query.selectSingle(pageid,"name",null);
     if (nameTriple==null)
       nameTriple=query.selectSingle(pageid,"Property:Context_name",null);
     if (nameTriple!=null) 
       name=nameTriple.getObject().toString();
     init(query);
   } // constructor for Context
   
   // >>>{user defined topic code}{Context}{Context}
   // <<<{user defined topic code}{Context}{Context}
 } // class Context
 /**
  * Manager for Context
  */
 public static class ContextManager extends TopicBase {

   public String topicName="Context";
   public transient List<Context> mContexts=new ArrayList<Context>();
   public transient Map<String,Context> mContextMap=new LinkedHashMap<String,Context>();

   /**
    * get my Contexts
    */
   public List<Context> getContexts() {
     List<Context> result=this.mContexts;
     return result;
   }

   /**
    *  add a new Context 
    */
   public Context add(Context pContext) {
     mContexts.add(pContext);
     mContextMap.put(pContext.getPageid(),pContext);
     return pContext;
   }

   /**
    *  add a new Context from the given triple
    */
   public Context add(TripleQuery query,Triple pContextTriple) {
     Context lContext=new Context(query,pContextTriple);
     add(lContext);
     return lContext;
   }

   // reinitialize my mContext map
   public void reinit() {
     mContextMap.clear();
     for (Context lContext:mContexts) {
       mContextMap.put(lContext.getPageid(),lContext);
     }
   }

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

   // default constructor 
   public ContextManager() {}

   // construct me from the given triple Query query
   public ContextManager(TripleQuery query) {
     // first query the SiDIF bases triplestore
     TripleQuery lContextQuery=query.query(null,"isA","Context");
     for (Triple lContextTriple:lContextQuery.getTriples()) {
       add(query,lContextTriple);
     }
     // then the SMW triplestore
     lContextQuery=query.query(null,"Property:IsA","Context");
     for (Triple lContextTriple:lContextQuery.getTriples()) {
       add(query,lContextTriple);
     }
     init(query);
   } // constructor for Context Manager
   
   // >>>{user defined topicmanager code}{Context}{Context}
   // <<<{user defined topicmanager code}{Context}{Context}
 } // class Context Manager
/**
 * Property
 * a Property is a Feature/Attribute of a Topic
 */
 public static class Property extends TopicBase {
   public String pageid;
   public String name;
   public String label;
   public String type;
   public String index;
   public String sortPos;
   public String primaryKey;
   public String mandatory;
   public String namespace;
   public String size;
   public String uploadable;
   public String defaultValue;
   public String inputType;
   public String allowedValues;
   public String documentation;
   public String values_from;
   public String showInGrid;
   public String isLink;
   public String nullable;
   public String topic;

   public String getName() { return name; }
   public void setName(String pName) { name=pName; }
   public String getLabel() { return label; }
   public void setLabel(String pLabel) { label=pLabel; }
   public String getType() { return type; }
   public void setType(String pType) { type=pType; }
   public String getIndex() { return index; }
   public void setIndex(String pIndex) { index=pIndex; }
   public String getSortPos() { return sortPos; }
   public void setSortPos(String pSortPos) { sortPos=pSortPos; }
   public String getPrimaryKey() { return primaryKey; }
   public void setPrimaryKey(String pPrimaryKey) { primaryKey=pPrimaryKey; }
   public String getMandatory() { return mandatory; }
   public void setMandatory(String pMandatory) { mandatory=pMandatory; }
   public String getNamespace() { return namespace; }
   public void setNamespace(String pNamespace) { namespace=pNamespace; }
   public String getSize() { return size; }
   public void setSize(String pSize) { size=pSize; }
   public String getUploadable() { return uploadable; }
   public void setUploadable(String pUploadable) { uploadable=pUploadable; }
   public String getDefaultValue() { return defaultValue; }
   public void setDefaultValue(String pDefaultValue) { defaultValue=pDefaultValue; }
   public String getInputType() { return inputType; }
   public void setInputType(String pInputType) { inputType=pInputType; }
   public String getAllowedValues() { return allowedValues; }
   public void setAllowedValues(String pAllowedValues) { allowedValues=pAllowedValues; }
   public String getDocumentation() { return documentation; }
   public void setDocumentation(String pDocumentation) { documentation=pDocumentation; }
   public String getValues_from() { return values_from; }
   public void setValues_from(String pValues_from) { values_from=pValues_from; }
   public String getShowInGrid() { return showInGrid; }
   public void setShowInGrid(String pShowInGrid) { showInGrid=pShowInGrid; }
   public String getIsLink() { return isLink; }
   public void setIsLink(String pIsLink) { isLink=pIsLink; }
   public String getNullable() { return nullable; }
   public void setNullable(String pNullable) { nullable=pNullable; }
   public String getTopic() { return topic; }
   public void setTopic(String pTopic) { topic=pTopic; }
   /**
    * convert this Property to a JSON string
    */
   public String toJson() { return JSON.toJSONString(this); }

   /**  
    * get the pageid for this topic
    */
   public String getPageid() { return pageid; };

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

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

   /**
    * construct a Property from the given pageId
    * @param query - the TripleQuery to get the triples from
    * @param pageid - pageid
    */
   public Property(TripleQuery query,String pageid) {
     this.pageid=pageid;
     Triple nameTriple=query.selectSingle(pageid,"name",null);
     if (nameTriple==null)
       nameTriple=query.selectSingle(pageid,"Property:Property_name",null);
     if (nameTriple!=null) 
       name=nameTriple.getObject().toString();
     Triple labelTriple=query.selectSingle(pageid,"label",null);
     if (labelTriple==null)
       labelTriple=query.selectSingle(pageid,"Property:Property_label",null);
     if (labelTriple!=null) 
       label=labelTriple.getObject().toString();
     Triple typeTriple=query.selectSingle(pageid,"type",null);
     if (typeTriple==null)
       typeTriple=query.selectSingle(pageid,"Property:Property_type",null);
     if (typeTriple!=null) 
       type=typeTriple.getObject().toString();
     Triple indexTriple=query.selectSingle(pageid,"index",null);
     if (indexTriple==null)
       indexTriple=query.selectSingle(pageid,"Property:Property_index",null);
     if (indexTriple!=null) 
       index=indexTriple.getObject().toString();
     Triple sortPosTriple=query.selectSingle(pageid,"sortPos",null);
     if (sortPosTriple==null)
       sortPosTriple=query.selectSingle(pageid,"Property:Property_sortPos",null);
     if (sortPosTriple!=null) 
       sortPos=sortPosTriple.getObject().toString();
     Triple primaryKeyTriple=query.selectSingle(pageid,"primaryKey",null);
     if (primaryKeyTriple==null)
       primaryKeyTriple=query.selectSingle(pageid,"Property:Property_primaryKey",null);
     if (primaryKeyTriple!=null) 
       primaryKey=primaryKeyTriple.getObject().toString();
     Triple mandatoryTriple=query.selectSingle(pageid,"mandatory",null);
     if (mandatoryTriple==null)
       mandatoryTriple=query.selectSingle(pageid,"Property:Property_mandatory",null);
     if (mandatoryTriple!=null) 
       mandatory=mandatoryTriple.getObject().toString();
     Triple namespaceTriple=query.selectSingle(pageid,"namespace",null);
     if (namespaceTriple==null)
       namespaceTriple=query.selectSingle(pageid,"Property:Property_namespace",null);
     if (namespaceTriple!=null) 
       namespace=namespaceTriple.getObject().toString();
     Triple sizeTriple=query.selectSingle(pageid,"size",null);
     if (sizeTriple==null)
       sizeTriple=query.selectSingle(pageid,"Property:Property_size",null);
     if (sizeTriple!=null) 
       size=sizeTriple.getObject().toString();
     Triple uploadableTriple=query.selectSingle(pageid,"uploadable",null);
     if (uploadableTriple==null)
       uploadableTriple=query.selectSingle(pageid,"Property:Property_uploadable",null);
     if (uploadableTriple!=null) 
       uploadable=uploadableTriple.getObject().toString();
     Triple defaultValueTriple=query.selectSingle(pageid,"defaultValue",null);
     if (defaultValueTriple==null)
       defaultValueTriple=query.selectSingle(pageid,"Property:Property_defaultValue",null);
     if (defaultValueTriple!=null) 
       defaultValue=defaultValueTriple.getObject().toString();
     Triple inputTypeTriple=query.selectSingle(pageid,"inputType",null);
     if (inputTypeTriple==null)
       inputTypeTriple=query.selectSingle(pageid,"Property:Property_inputType",null);
     if (inputTypeTriple!=null) 
       inputType=inputTypeTriple.getObject().toString();
     Triple allowedValuesTriple=query.selectSingle(pageid,"allowedValues",null);
     if (allowedValuesTriple==null)
       allowedValuesTriple=query.selectSingle(pageid,"Property:Property_allowedValues",null);
     if (allowedValuesTriple!=null) 
       allowedValues=allowedValuesTriple.getObject().toString();
     Triple documentationTriple=query.selectSingle(pageid,"documentation",null);
     if (documentationTriple==null)
       documentationTriple=query.selectSingle(pageid,"Property:Property_documentation",null);
     if (documentationTriple!=null) 
       documentation=documentationTriple.getObject().toString();
     Triple values_fromTriple=query.selectSingle(pageid,"values_from",null);
     if (values_fromTriple==null)
       values_fromTriple=query.selectSingle(pageid,"Property:Property_values_from",null);
     if (values_fromTriple!=null) 
       values_from=values_fromTriple.getObject().toString();
     Triple showInGridTriple=query.selectSingle(pageid,"showInGrid",null);
     if (showInGridTriple==null)
       showInGridTriple=query.selectSingle(pageid,"Property:Property_showInGrid",null);
     if (showInGridTriple!=null) 
       showInGrid=showInGridTriple.getObject().toString();
     Triple isLinkTriple=query.selectSingle(pageid,"isLink",null);
     if (isLinkTriple==null)
       isLinkTriple=query.selectSingle(pageid,"Property:Property_isLink",null);
     if (isLinkTriple!=null) 
       isLink=isLinkTriple.getObject().toString();
     Triple nullableTriple=query.selectSingle(pageid,"nullable",null);
     if (nullableTriple==null)
       nullableTriple=query.selectSingle(pageid,"Property:Property_nullable",null);
     if (nullableTriple!=null) 
       nullable=nullableTriple.getObject().toString();
     Triple topicTriple=query.selectSingle(pageid,"topic",null);
     if (topicTriple==null)
       topicTriple=query.selectSingle(pageid,"Property:Property_topic",null);
     if (topicTriple!=null) 
       topic=topicTriple.getObject().toString();
     init(query);
   } // constructor for Property
   
   // >>>{user defined topic code}{Property}{Property}
   // <<<{user defined topic code}{Property}{Property}
 } // class Property
 /**
  * Manager for Property
  */
 public static class PropertyManager extends TopicBase {

   public String topicName="Property";
   public transient List<Property> mPropertys=new ArrayList<Property>();
   public transient Map<String,Property> mPropertyMap=new LinkedHashMap<String,Property>();

   /**
    * get my Properties
    */
   public List<Property> getProperties() {
     List<Property> result=this.mPropertys;
     return result;
   }

   /**
    *  add a new Property 
    */
   public Property add(Property pProperty) {
     mPropertys.add(pProperty);
     mPropertyMap.put(pProperty.getPageid(),pProperty);
     return pProperty;
   }

   /**
    *  add a new Property from the given triple
    */
   public Property add(TripleQuery query,Triple pPropertyTriple) {
     Property lProperty=new Property(query,pPropertyTriple);
     add(lProperty);
     return lProperty;
   }

   // reinitialize my mProperty map
   public void reinit() {
     mPropertyMap.clear();
     for (Property lProperty:mPropertys) {
       mPropertyMap.put(lProperty.getPageid(),lProperty);
     }
   }

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

   // default constructor 
   public PropertyManager() {}

   // construct me from the given triple Query query
   public PropertyManager(TripleQuery query) {
     // first query the SiDIF bases triplestore
     TripleQuery lPropertyQuery=query.query(null,"isA","Property");
     for (Triple lPropertyTriple:lPropertyQuery.getTriples()) {
       add(query,lPropertyTriple);
     }
     // then the SMW triplestore
     lPropertyQuery=query.query(null,"Property:IsA","Property");
     for (Triple lPropertyTriple:lPropertyQuery.getTriples()) {
       add(query,lPropertyTriple);
     }
     init(query);
   } // constructor for Property Manager
   
   // >>>{user defined topicmanager code}{Property}{Property}
   // <<<{user defined topicmanager code}{Property}{Property}
 } // class Property Manager
/**
 * SMW_Type
 * an SMW_Type is a data type which determines the possible values for that type e.g. a Boolean can hold true/fals values while a Number can hold 3.1459 or 20. A Page can hold the name of a Wiki page see https://semantic-mediawiki.org/wiki/Help:List_of_datatypes
 */
 public static class SMW_Type extends TopicBase {
   public String pageid;
   public String type;
   public String documentation;
   public String helppage;
   public String typepage;
   public String javaType;
   public String usedByProperties;

   public String getType() { return type; }
   public void setType(String pType) { type=pType; }
   public String getDocumentation() { return documentation; }
   public void setDocumentation(String pDocumentation) { documentation=pDocumentation; }
   public String getHelppage() { return helppage; }
   public void setHelppage(String pHelppage) { helppage=pHelppage; }
   public String getTypepage() { return typepage; }
   public void setTypepage(String pTypepage) { typepage=pTypepage; }
   public String getJavaType() { return javaType; }
   public void setJavaType(String pJavaType) { javaType=pJavaType; }
   public String getUsedByProperties() { return usedByProperties; }
   public void setUsedByProperties(String pUsedByProperties) { usedByProperties=pUsedByProperties; }
   /**
    * convert this SMW_Type to a JSON string
    */
   public String toJson() { return JSON.toJSONString(this); }

   /**  
    * get the pageid for this topic
    */
   public String getPageid() { return pageid; };

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

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

   /**
    * construct a SMW_Type from the given pageId
    * @param query - the TripleQuery to get the triples from
    * @param pageid - pageid
    */
   public SMW_Type(TripleQuery query,String pageid) {
     this.pageid=pageid;
     Triple typeTriple=query.selectSingle(pageid,"type",null);
     if (typeTriple==null)
       typeTriple=query.selectSingle(pageid,"Property:SMW_Type_type",null);
     if (typeTriple!=null) 
       type=typeTriple.getObject().toString();
     Triple documentationTriple=query.selectSingle(pageid,"documentation",null);
     if (documentationTriple==null)
       documentationTriple=query.selectSingle(pageid,"Property:SMW_Type_documentation",null);
     if (documentationTriple!=null) 
       documentation=documentationTriple.getObject().toString();
     Triple helppageTriple=query.selectSingle(pageid,"helppage",null);
     if (helppageTriple==null)
       helppageTriple=query.selectSingle(pageid,"Property:SMW_Type_helppage",null);
     if (helppageTriple!=null) 
       helppage=helppageTriple.getObject().toString();
     Triple typepageTriple=query.selectSingle(pageid,"typepage",null);
     if (typepageTriple==null)
       typepageTriple=query.selectSingle(pageid,"Property:SMW_Type_typepage",null);
     if (typepageTriple!=null) 
       typepage=typepageTriple.getObject().toString();
     Triple javaTypeTriple=query.selectSingle(pageid,"javaType",null);
     if (javaTypeTriple==null)
       javaTypeTriple=query.selectSingle(pageid,"Property:SMW_Type_javaType",null);
     if (javaTypeTriple!=null) 
       javaType=javaTypeTriple.getObject().toString();
     Triple usedByPropertiesTriple=query.selectSingle(pageid,"usedByProperties",null);
     if (usedByPropertiesTriple==null)
       usedByPropertiesTriple=query.selectSingle(pageid,"Property:SMW_Type_usedByProperties",null);
     if (usedByPropertiesTriple!=null) 
       usedByProperties=usedByPropertiesTriple.getObject().toString();
     init(query);
   } // constructor for SMW_Type
   
   // >>>{user defined topic code}{SMW_Type}{SMW_Type}
   // <<<{user defined topic code}{SMW_Type}{SMW_Type}
 } // class SMW_Type
 /**
  * Manager for SMW_Type
  */
 public static class SMW_TypeManager extends TopicBase {

   public String topicName="SMW_Type";
   public transient List<SMW_Type> mSMW_Types=new ArrayList<SMW_Type>();
   public transient Map<String,SMW_Type> mSMW_TypeMap=new LinkedHashMap<String,SMW_Type>();

   /**
    * get my SMW_Types
    */
   public List<SMW_Type> getSMW_Types() {
     List<SMW_Type> result=this.mSMW_Types;
     return result;
   }

   /**
    *  add a new SMW_Type 
    */
   public SMW_Type add(SMW_Type pSMW_Type) {
     mSMW_Types.add(pSMW_Type);
     mSMW_TypeMap.put(pSMW_Type.getPageid(),pSMW_Type);
     return pSMW_Type;
   }

   /**
    *  add a new SMW_Type from the given triple
    */
   public SMW_Type add(TripleQuery query,Triple pSMW_TypeTriple) {
     SMW_Type lSMW_Type=new SMW_Type(query,pSMW_TypeTriple);
     add(lSMW_Type);
     return lSMW_Type;
   }

   // reinitialize my mSMW_Type map
   public void reinit() {
     mSMW_TypeMap.clear();
     for (SMW_Type lSMW_Type:mSMW_Types) {
       mSMW_TypeMap.put(lSMW_Type.getPageid(),lSMW_Type);
     }
   }

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

   // default constructor 
   public SMW_TypeManager() {}

   // construct me from the given triple Query query
   public SMW_TypeManager(TripleQuery query) {
     // first query the SiDIF bases triplestore
     TripleQuery lSMW_TypeQuery=query.query(null,"isA","SMW_Type");
     for (Triple lSMW_TypeTriple:lSMW_TypeQuery.getTriples()) {
       add(query,lSMW_TypeTriple);
     }
     // then the SMW triplestore
     lSMW_TypeQuery=query.query(null,"Property:IsA","SMW_Type");
     for (Triple lSMW_TypeTriple:lSMW_TypeQuery.getTriples()) {
       add(query,lSMW_TypeTriple);
     }
     init(query);
   } // constructor for SMW_Type Manager
   
   // >>>{user defined topicmanager code}{SMW_Type}{SMW_Type}
   // <<<{user defined topicmanager code}{SMW_Type}{SMW_Type}
 } // class SMW_Type Manager
/**
 * Topic
 * A Topic is a Concept/Class/Thing/Entity
 */
 public static class Topic extends TopicBase {
   public String pageid;
   public String name;
   public String pluralName;
   public String icon;
   public String iconUrl;
   public String documentation;
   public String wikiDocumentation;
   public String defaultstoremode;
   public String listLimit;
   public String cargo;
   public String context;

   public String getName() { return name; }
   public void setName(String pName) { name=pName; }
   public String getPluralName() { return pluralName; }
   public void setPluralName(String pPluralName) { pluralName=pPluralName; }
   public String getIcon() { return icon; }
   public void setIcon(String pIcon) { icon=pIcon; }
   public String getIconUrl() { return iconUrl; }
   public void setIconUrl(String pIconUrl) { iconUrl=pIconUrl; }
   public String getDocumentation() { return documentation; }
   public void setDocumentation(String pDocumentation) { documentation=pDocumentation; }
   public String getWikiDocumentation() { return wikiDocumentation; }
   public void setWikiDocumentation(String pWikiDocumentation) { wikiDocumentation=pWikiDocumentation; }
   public String getDefaultstoremode() { return defaultstoremode; }
   public void setDefaultstoremode(String pDefaultstoremode) { defaultstoremode=pDefaultstoremode; }
   public String getListLimit() { return listLimit; }
   public void setListLimit(String pListLimit) { listLimit=pListLimit; }
   public String getCargo() { return cargo; }
   public void setCargo(String pCargo) { cargo=pCargo; }
   public String getContext() { return context; }
   public void setContext(String pContext) { context=pContext; }
   /**
    * convert this Topic to a JSON string
    */
   public String toJson() { return JSON.toJSONString(this); }

   /**  
    * get the pageid for this topic
    */
   public String getPageid() { return pageid; };

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

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

   /**
    * construct a Topic from the given pageId
    * @param query - the TripleQuery to get the triples from
    * @param pageid - pageid
    */
   public Topic(TripleQuery query,String pageid) {
     this.pageid=pageid;
     Triple nameTriple=query.selectSingle(pageid,"name",null);
     if (nameTriple==null)
       nameTriple=query.selectSingle(pageid,"Property:Topic_name",null);
     if (nameTriple!=null) 
       name=nameTriple.getObject().toString();
     Triple pluralNameTriple=query.selectSingle(pageid,"pluralName",null);
     if (pluralNameTriple==null)
       pluralNameTriple=query.selectSingle(pageid,"Property:Topic_pluralName",null);
     if (pluralNameTriple!=null) 
       pluralName=pluralNameTriple.getObject().toString();
     Triple iconTriple=query.selectSingle(pageid,"icon",null);
     if (iconTriple==null)
       iconTriple=query.selectSingle(pageid,"Property:Topic_icon",null);
     if (iconTriple!=null) 
       icon=iconTriple.getObject().toString();
     Triple iconUrlTriple=query.selectSingle(pageid,"iconUrl",null);
     if (iconUrlTriple==null)
       iconUrlTriple=query.selectSingle(pageid,"Property:Topic_iconUrl",null);
     if (iconUrlTriple!=null) 
       iconUrl=iconUrlTriple.getObject().toString();
     Triple documentationTriple=query.selectSingle(pageid,"documentation",null);
     if (documentationTriple==null)
       documentationTriple=query.selectSingle(pageid,"Property:Topic_documentation",null);
     if (documentationTriple!=null) 
       documentation=documentationTriple.getObject().toString();
     Triple wikiDocumentationTriple=query.selectSingle(pageid,"wikiDocumentation",null);
     if (wikiDocumentationTriple==null)
       wikiDocumentationTriple=query.selectSingle(pageid,"Property:Topic_wikiDocumentation",null);
     if (wikiDocumentationTriple!=null) 
       wikiDocumentation=wikiDocumentationTriple.getObject().toString();
     Triple defaultstoremodeTriple=query.selectSingle(pageid,"defaultstoremode",null);
     if (defaultstoremodeTriple==null)
       defaultstoremodeTriple=query.selectSingle(pageid,"Property:Topic_defaultstoremode",null);
     if (defaultstoremodeTriple!=null) 
       defaultstoremode=defaultstoremodeTriple.getObject().toString();
     Triple listLimitTriple=query.selectSingle(pageid,"listLimit",null);
     if (listLimitTriple==null)
       listLimitTriple=query.selectSingle(pageid,"Property:Topic_listLimit",null);
     if (listLimitTriple!=null) 
       listLimit=listLimitTriple.getObject().toString();
     Triple cargoTriple=query.selectSingle(pageid,"cargo",null);
     if (cargoTriple==null)
       cargoTriple=query.selectSingle(pageid,"Property:Topic_cargo",null);
     if (cargoTriple!=null) 
       cargo=cargoTriple.getObject().toString();
     Triple contextTriple=query.selectSingle(pageid,"context",null);
     if (contextTriple==null)
       contextTriple=query.selectSingle(pageid,"Property:Topic_context",null);
     if (contextTriple!=null) 
       context=contextTriple.getObject().toString();
     init(query);
   } // constructor for Topic
   
   // >>>{user defined topic code}{Topic}{Topic}
   // <<<{user defined topic code}{Topic}{Topic}
 } // class Topic
 /**
  * Manager for Topic
  */
 public static class TopicManager extends TopicBase {

   public String topicName="Topic";
   public transient List<Topic> mTopics=new ArrayList<Topic>();
   public transient Map<String,Topic> mTopicMap=new LinkedHashMap<String,Topic>();

   /**
    * get my Topics
    */
   public List<Topic> getTopics() {
     List<Topic> result=this.mTopics;
     return result;
   }

   /**
    *  add a new Topic 
    */
   public Topic add(Topic pTopic) {
     mTopics.add(pTopic);
     mTopicMap.put(pTopic.getPageid(),pTopic);
     return pTopic;
   }

   /**
    *  add a new Topic from the given triple
    */
   public Topic add(TripleQuery query,Triple pTopicTriple) {
     Topic lTopic=new Topic(query,pTopicTriple);
     add(lTopic);
     return lTopic;
   }

   // reinitialize my mTopic map
   public void reinit() {
     mTopicMap.clear();
     for (Topic lTopic:mTopics) {
       mTopicMap.put(lTopic.getPageid(),lTopic);
     }
   }

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

   // default constructor 
   public TopicManager() {}

   // construct me from the given triple Query query
   public TopicManager(TripleQuery query) {
     // first query the SiDIF bases triplestore
     TripleQuery lTopicQuery=query.query(null,"isA","Topic");
     for (Triple lTopicTriple:lTopicQuery.getTriples()) {
       add(query,lTopicTriple);
     }
     // then the SMW triplestore
     lTopicQuery=query.query(null,"Property:IsA","Topic");
     for (Triple lTopicTriple:lTopicQuery.getTriples()) {
       add(query,lTopicTriple);
     }
     init(query);
   } // constructor for Topic Manager
   
   // >>>{user defined topicmanager code}{Topic}{Topic}
   // <<<{user defined topicmanager code}{Topic}{Topic}
 } // class Topic Manager
/**
 * Action
 * 
 */
 public static class Action extends TopicBase {
   public String pageid;
   public String servicetype;
   public String service;
   public String inputtype;
   public String input;
   public String actionpage;
   public String output;

   public String getServicetype() { return servicetype; }
   public void setServicetype(String pServicetype) { servicetype=pServicetype; }
   public String getService() { return service; }
   public void setService(String pService) { service=pService; }
   public String getInputtype() { return inputtype; }
   public void setInputtype(String pInputtype) { inputtype=pInputtype; }
   public String getInput() { return input; }
   public void setInput(String pInput) { input=pInput; }
   public String getActionpage() { return actionpage; }
   public void setActionpage(String pActionpage) { actionpage=pActionpage; }
   public String getOutput() { return output; }
   public void setOutput(String pOutput) { output=pOutput; }
   /**
    * convert this Action to a JSON string
    */
   public String toJson() { return JSON.toJSONString(this); }

   /**  
    * get the pageid for this topic
    */
   public String getPageid() { return pageid; };

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

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

   /**
    * construct a Action from the given pageId
    * @param query - the TripleQuery to get the triples from
    * @param pageid - pageid
    */
   public Action(TripleQuery query,String pageid) {
     this.pageid=pageid;
     Triple servicetypeTriple=query.selectSingle(pageid,"servicetype",null);
     if (servicetypeTriple==null)
       servicetypeTriple=query.selectSingle(pageid,"Property:Action_servicetype",null);
     if (servicetypeTriple!=null) 
       servicetype=servicetypeTriple.getObject().toString();
     Triple serviceTriple=query.selectSingle(pageid,"service",null);
     if (serviceTriple==null)
       serviceTriple=query.selectSingle(pageid,"Property:Action_service",null);
     if (serviceTriple!=null) 
       service=serviceTriple.getObject().toString();
     Triple inputtypeTriple=query.selectSingle(pageid,"inputtype",null);
     if (inputtypeTriple==null)
       inputtypeTriple=query.selectSingle(pageid,"Property:Action_inputtype",null);
     if (inputtypeTriple!=null) 
       inputtype=inputtypeTriple.getObject().toString();
     Triple inputTriple=query.selectSingle(pageid,"input",null);
     if (inputTriple==null)
       inputTriple=query.selectSingle(pageid,"Property:Action_input",null);
     if (inputTriple!=null) 
       input=inputTriple.getObject().toString();
     Triple actionpageTriple=query.selectSingle(pageid,"actionpage",null);
     if (actionpageTriple==null)
       actionpageTriple=query.selectSingle(pageid,"Property:Action_actionpage",null);
     if (actionpageTriple!=null) 
       actionpage=actionpageTriple.getObject().toString();
     Triple outputTriple=query.selectSingle(pageid,"output",null);
     if (outputTriple==null)
       outputTriple=query.selectSingle(pageid,"Property:Action_output",null);
     if (outputTriple!=null) 
       output=outputTriple.getObject().toString();
     init(query);
   } // constructor for Action
   
   // >>>{user defined topic code}{Action}{Action}
   // <<<{user defined topic code}{Action}{Action}
 } // class Action
 /**
  * Manager for Action
  */
 public static class ActionManager extends TopicBase {

   public String topicName="Action";
   public transient List<Action> mActions=new ArrayList<Action>();
   public transient Map<String,Action> mActionMap=new LinkedHashMap<String,Action>();

   /**
    * get my Actions
    */
   public List<Action> getActions() {
     List<Action> result=this.mActions;
     return result;
   }

   /**
    *  add a new Action 
    */
   public Action add(Action pAction) {
     mActions.add(pAction);
     mActionMap.put(pAction.getPageid(),pAction);
     return pAction;
   }

   /**
    *  add a new Action from the given triple
    */
   public Action add(TripleQuery query,Triple pActionTriple) {
     Action lAction=new Action(query,pActionTriple);
     add(lAction);
     return lAction;
   }

   // reinitialize my mAction map
   public void reinit() {
     mActionMap.clear();
     for (Action lAction:mActions) {
       mActionMap.put(lAction.getPageid(),lAction);
     }
   }

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

   // default constructor 
   public ActionManager() {}

   // construct me from the given triple Query query
   public ActionManager(TripleQuery query) {
     // first query the SiDIF bases triplestore
     TripleQuery lActionQuery=query.query(null,"isA","Action");
     for (Triple lActionTriple:lActionQuery.getTriples()) {
       add(query,lActionTriple);
     }
     // then the SMW triplestore
     lActionQuery=query.query(null,"Property:IsA","Action");
     for (Triple lActionTriple:lActionQuery.getTriples()) {
       add(query,lActionTriple);
     }
     init(query);
   } // constructor for Action Manager
   
   // >>>{user defined topicmanager code}{Action}{Action}
   // <<<{user defined topicmanager code}{Action}{Action}
 } // class Action Manager
/**
 * TopicLink
 * A TopicLink links two Concepts
 */
 public static class TopicLink extends TopicBase {
   public String pageid;
   public String name;
   public String source;
   public String sourceRole;
   public String sourceMultiple;
   public String sourceDocumentation;
   public String target;
   public String targetRole;
   public String targetMultiple;
   public String targetDocumentation;
   public String masterDetail;

   public String getName() { return name; }
   public void setName(String pName) { name=pName; }
   public String getSource() { return source; }
   public void setSource(String pSource) { source=pSource; }
   public String getSourceRole() { return sourceRole; }
   public void setSourceRole(String pSourceRole) { sourceRole=pSourceRole; }
   public String getSourceMultiple() { return sourceMultiple; }
   public void setSourceMultiple(String pSourceMultiple) { sourceMultiple=pSourceMultiple; }
   public String getSourceDocumentation() { return sourceDocumentation; }
   public void setSourceDocumentation(String pSourceDocumentation) { sourceDocumentation=pSourceDocumentation; }
   public String getTarget() { return target; }
   public void setTarget(String pTarget) { target=pTarget; }
   public String getTargetRole() { return targetRole; }
   public void setTargetRole(String pTargetRole) { targetRole=pTargetRole; }
   public String getTargetMultiple() { return targetMultiple; }
   public void setTargetMultiple(String pTargetMultiple) { targetMultiple=pTargetMultiple; }
   public String getTargetDocumentation() { return targetDocumentation; }
   public void setTargetDocumentation(String pTargetDocumentation) { targetDocumentation=pTargetDocumentation; }
   public String getMasterDetail() { return masterDetail; }
   public void setMasterDetail(String pMasterDetail) { masterDetail=pMasterDetail; }
   /**
    * convert this TopicLink to a JSON string
    */
   public String toJson() { return JSON.toJSONString(this); }

   /**  
    * get the pageid for this topic
    */
   public String getPageid() { return pageid; };

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

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

   /**
    * construct a TopicLink from the given pageId
    * @param query - the TripleQuery to get the triples from
    * @param pageid - pageid
    */
   public TopicLink(TripleQuery query,String pageid) {
     this.pageid=pageid;
     Triple nameTriple=query.selectSingle(pageid,"name",null);
     if (nameTriple==null)
       nameTriple=query.selectSingle(pageid,"Property:TopicLink_name",null);
     if (nameTriple!=null) 
       name=nameTriple.getObject().toString();
     Triple sourceTriple=query.selectSingle(pageid,"source",null);
     if (sourceTriple==null)
       sourceTriple=query.selectSingle(pageid,"Property:TopicLink_source",null);
     if (sourceTriple!=null) 
       source=sourceTriple.getObject().toString();
     Triple sourceRoleTriple=query.selectSingle(pageid,"sourceRole",null);
     if (sourceRoleTriple==null)
       sourceRoleTriple=query.selectSingle(pageid,"Property:TopicLink_sourceRole",null);
     if (sourceRoleTriple!=null) 
       sourceRole=sourceRoleTriple.getObject().toString();
     Triple sourceMultipleTriple=query.selectSingle(pageid,"sourceMultiple",null);
     if (sourceMultipleTriple==null)
       sourceMultipleTriple=query.selectSingle(pageid,"Property:TopicLink_sourceMultiple",null);
     if (sourceMultipleTriple!=null) 
       sourceMultiple=sourceMultipleTriple.getObject().toString();
     Triple sourceDocumentationTriple=query.selectSingle(pageid,"sourceDocumentation",null);
     if (sourceDocumentationTriple==null)
       sourceDocumentationTriple=query.selectSingle(pageid,"Property:TopicLink_sourceDocumentation",null);
     if (sourceDocumentationTriple!=null) 
       sourceDocumentation=sourceDocumentationTriple.getObject().toString();
     Triple targetTriple=query.selectSingle(pageid,"target",null);
     if (targetTriple==null)
       targetTriple=query.selectSingle(pageid,"Property:TopicLink_target",null);
     if (targetTriple!=null) 
       target=targetTriple.getObject().toString();
     Triple targetRoleTriple=query.selectSingle(pageid,"targetRole",null);
     if (targetRoleTriple==null)
       targetRoleTriple=query.selectSingle(pageid,"Property:TopicLink_targetRole",null);
     if (targetRoleTriple!=null) 
       targetRole=targetRoleTriple.getObject().toString();
     Triple targetMultipleTriple=query.selectSingle(pageid,"targetMultiple",null);
     if (targetMultipleTriple==null)
       targetMultipleTriple=query.selectSingle(pageid,"Property:TopicLink_targetMultiple",null);
     if (targetMultipleTriple!=null) 
       targetMultiple=targetMultipleTriple.getObject().toString();
     Triple targetDocumentationTriple=query.selectSingle(pageid,"targetDocumentation",null);
     if (targetDocumentationTriple==null)
       targetDocumentationTriple=query.selectSingle(pageid,"Property:TopicLink_targetDocumentation",null);
     if (targetDocumentationTriple!=null) 
       targetDocumentation=targetDocumentationTriple.getObject().toString();
     Triple masterDetailTriple=query.selectSingle(pageid,"masterDetail",null);
     if (masterDetailTriple==null)
       masterDetailTriple=query.selectSingle(pageid,"Property:TopicLink_masterDetail",null);
     if (masterDetailTriple!=null) 
       masterDetail=masterDetailTriple.getObject().toString();
     init(query);
   } // constructor for TopicLink
   
   // >>>{user defined topic code}{TopicLink}{TopicLink}
   // <<<{user defined topic code}{TopicLink}{TopicLink}
 } // class TopicLink
 /**
  * Manager for TopicLink
  */
 public static class TopicLinkManager extends TopicBase {

   public String topicName="TopicLink";
   public transient List<TopicLink> mTopicLinks=new ArrayList<TopicLink>();
   public transient Map<String,TopicLink> mTopicLinkMap=new LinkedHashMap<String,TopicLink>();

   /**
    * get my TopicLinks
    */
   public List<TopicLink> getTopicLinks() {
     List<TopicLink> result=this.mTopicLinks;
     return result;
   }

   /**
    *  add a new TopicLink 
    */
   public TopicLink add(TopicLink pTopicLink) {
     mTopicLinks.add(pTopicLink);
     mTopicLinkMap.put(pTopicLink.getPageid(),pTopicLink);
     return pTopicLink;
   }

   /**
    *  add a new TopicLink from the given triple
    */
   public TopicLink add(TripleQuery query,Triple pTopicLinkTriple) {
     TopicLink lTopicLink=new TopicLink(query,pTopicLinkTriple);
     add(lTopicLink);
     return lTopicLink;
   }

   // reinitialize my mTopicLink map
   public void reinit() {
     mTopicLinkMap.clear();
     for (TopicLink lTopicLink:mTopicLinks) {
       mTopicLinkMap.put(lTopicLink.getPageid(),lTopicLink);
     }
   }

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

   // default constructor 
   public TopicLinkManager() {}

   // construct me from the given triple Query query
   public TopicLinkManager(TripleQuery query) {
     // first query the SiDIF bases triplestore
     TripleQuery lTopicLinkQuery=query.query(null,"isA","TopicLink");
     for (Triple lTopicLinkTriple:lTopicLinkQuery.getTriples()) {
       add(query,lTopicLinkTriple);
     }
     // then the SMW triplestore
     lTopicLinkQuery=query.query(null,"Property:IsA","TopicLink");
     for (Triple lTopicLinkTriple:lTopicLinkQuery.getTriples()) {
       add(query,lTopicLinkTriple);
     }
     init(query);
   } // constructor for TopicLink Manager
   
   // >>>{user defined topicmanager code}{TopicLink}{TopicLink}
   // <<<{user defined topicmanager code}{TopicLink}{TopicLink}
 } // class TopicLink Manager

}