public ObjectClassViewModel(
     IViewModelDependencies appCtx, IZetboxContext dataCtx, ViewModel parent,
     ObjectClass cls)
     : base(appCtx, dataCtx, parent, cls)
 {
     _class = cls;
 }

        public static string InheritanceAssociationName(ObjectClass parentClass, ObjectClass childClass)
        {
            if (parentClass == null) { throw new ArgumentNullException("parentClass"); }
            if (childClass == null) { throw new ArgumentNullException("childClass"); }

            return InheritanceAssociationName(parentClass.Name, childClass.Name);
        }

        public static object[] MakeArgs(IZetboxContext ctx, ObjectClass cls, NameValueCollection templateSettings)
        {
            if (ctx == null) { throw new ArgumentNullException("ctx"); }
            if (cls == null) { throw new ArgumentNullException("cls"); }
            if (templateSettings == null) { throw new ArgumentNullException("templateSettings"); }

            string extraSuffix = templateSettings["extrasuffix"];
            string interfaceName = cls.Name;
            string implementationName = cls.Name + extraSuffix + Zetbox.API.Helper.ImplementationSuffix;
            string schemaName = cls.Module.SchemaName;
            string tableName = cls.TableName;

            string qualifiedImplementationName = GetAssemblyQualifiedProxy(cls, templateSettings);

            bool isAbstract = cls.IsAbstract;

            List<Property> properties = cls.Properties.ToList();
            List<ObjectClass> subClasses = cls.SubClasses.ToList();

            bool needsRightTable = Templates.ObjectClasses.Template.NeedsRightsTable(cls);
            string qualifiedRightsClassName =
                cls.Module.Namespace + "."
                + Construct.SecurityRulesClassName(cls) + extraSuffix + Zetbox.API.Helper.ImplementationSuffix
                + ", Zetbox.Objects." + extraSuffix + Zetbox.API.Helper.ImplementationSuffix;

            bool needsConcurrency = cls.ImplementsIChangedBy(true);

            return new object[] { interfaceName, implementationName, schemaName, tableName, qualifiedImplementationName, isAbstract, properties, subClasses, needsRightTable, needsConcurrency, qualifiedRightsClassName, cls.GetTableMapping() };
        }

        public ModelMslEntityTypeMapping(Arebis.CodeGeneration.IGenerationHost _host, IZetboxContext ctx, ObjectClass cls)
            : base(_host)
        {
			this.ctx = ctx;
			this.cls = cls;

        }

 protected virtual void ApplyObjectClassTemplate(ObjectClass cls)
 {
     this.CallTemplate("Mappings.ObjectClassHbm",
          new object[] { ctx }
              .Concat(ObjectClassHbm.MakeArgs(ctx, cls, new NameValueCollection() { { "extrasuffix", extraSuffix } }))
              .ToArray());
 }

        public static void Call(Arebis.CodeGeneration.IGenerationHost host, IZetboxContext ctx, ObjectClass cls, string ifName, string implName)
        {
            if (host == null) { throw new ArgumentNullException("host"); }

            string propertyDescriptorName = host.Settings["propertydescriptorname"];
            host.CallTemplate("ObjectClasses.CustomTypeDescriptor", ctx, cls, ifName, implName, propertyDescriptorName);
        }

 public ObjectClassViewModel(IViewModelDependencies appCtx,
     IZetboxContext dataCtx, ViewModel parent, ObjectClass cls)
     : base(appCtx, dataCtx, parent, cls)
 {
     _cls = cls;
     cls.PropertyChanged += ModulePropertyChanged;
 }

        public AttachToContextTemplate(Arebis.CodeGeneration.IGenerationHost _host, IZetboxContext ctx, ObjectClass cls)
            : base(_host)
        {
			this.ctx = ctx;
			this.cls = cls;

        }

 public override void RenderObjectAs(ObjectContext context, ObjectClass objectClass)
 {
     if(!string.IsNullOrEmpty(objectClass.Atts["Table"]))
         RenderTableObjectAs(context, objectClass);
     else if(!string.IsNullOrEmpty(objectClass.Atts["Proc"]))
         RenderProcObjectAs(context, objectClass);
 }

        public FilterListViewModel(IViewModelDependencies appCtx, IZetboxContext dataCtx, ViewModel parent, ObjectClass type, IFulltextSupport fulltextSupport = null)
            : base(appCtx, dataCtx, parent)
        {
            if (type == null) throw new ArgumentNullException("type");

            _type = type;
            _fulltextSupport = fulltextSupport;
        }

 protected static IEnumerable<ObjectClass> SelectAndParents(ObjectClass cls)
 {
     yield return cls;
     while (cls.BaseObjectClass != null)
     {
         cls = cls.BaseObjectClass;
         yield return cls;
     }
 }

        public SecurityRulesClass(Arebis.CodeGeneration.IGenerationHost _host, IZetboxContext ctx, ObjectClass cls, string assocName, string targetRoleName, string referencedImplementation)
            : base(_host)
        {
			this.ctx = ctx;
			this.cls = cls;
			this.assocName = assocName;
			this.targetRoleName = targetRoleName;
			this.referencedImplementation = referencedImplementation;

        }

        public CustomTypeDescriptor(Arebis.CodeGeneration.IGenerationHost _host, IZetboxContext ctx, ObjectClass cls, string ifName, string implName, string propertyDescriptorName)
            : base(_host)
        {
			this.ctx = ctx;
			this.cls = cls;
			this.ifName = ifName;
			this.implName = implName;
			this.propertyDescriptorName = propertyDescriptorName;

        }

 public static void Call(IGenerationHost host, IZetboxContext ctx, ObjectClass cls)
 {
     if (host == null) { throw new ArgumentNullException("host"); }
     if (ctx == null) { throw new ArgumentNullException("ctx"); }
     if (cls == null) { throw new ArgumentNullException("cls"); }
     host.CallTemplate("ObjectClasses.SecurityRulesClass", ctx, cls,
         Construct.SecurityRulesFKName(cls),
         Construct.SecurityRulesClassName(cls),
         Construct.SecurityRulesClassName(cls) + host.Settings["extrasuffix"] + Zetbox.API.Helper.ImplementationSuffix);
 }

        public static string GetWrapperTypeReference(ObjectClass cls, NameValueCollection templateSettings)
        {
            if (cls == null) { throw new ArgumentNullException("cls"); }
            if (templateSettings == null) { throw new ArgumentNullException("templateSettings"); }

            string extraSuffix = templateSettings["extrasuffix"];

            return cls.Module.Namespace + "."
                + cls.Name + extraSuffix + Zetbox.API.Helper.ImplementationSuffix;
        }

        public ModelSsdlEntityTypeColumnsRel(Arebis.CodeGeneration.IGenerationHost _host, IZetboxContext ctx, ObjectClass cls, IEnumerable<Relation> relations, string prefix, ISchemaProvider schemaProvider)
            : base(_host)
        {
			this.ctx = ctx;
			this.cls = cls;
			this.relations = relations;
			this.prefix = prefix;
			this.schemaProvider = schemaProvider;

        }

        public static bool Required(ObjectClass objectClass, string name)
        {
            if (objectClass == ObjectClass.Armor || objectClass == ObjectClass.Clothing ||
                objectClass == ObjectClass.MeleeWeapon || objectClass == ObjectClass.MissileWeapon || objectClass == ObjectClass.WandStaffOrb ||
                objectClass == ObjectClass.Jewelry ||
                (objectClass == ObjectClass.Gem && !String.IsNullOrEmpty(name) && name.Contains("Aetheria")) || // Aetheria are Gems
                (objectClass == ObjectClass.Misc && !String.IsNullOrEmpty(name) && name.Contains("Essence"))) // Essences (Summoning Gems) are Misc
                return true;

            return false;
        }

        public PropertySelectionTaskViewModel(
            IViewModelDependencies appCtx, IZetboxContext dataCtx, ViewModel parent,
            ObjectClass objClass,
            Action<IEnumerable<Property>> callback)
            : base(appCtx, dataCtx, parent)
        {
            if (objClass == null) throw new ArgumentNullException("objClass");
            if (callback == null) throw new ArgumentNullException("callback");

            _callback = callback;
            _objClass = objClass;
        }

 public TreeItemInstanceListViewModel(
     IViewModelDependencies appCtx,
     ZetboxConfig config,
     IFileOpener fileOpener,
     ITempFileService tmpService,
     Lazy<IUIExceptionReporter> errorReporter,
     IZetboxContext dataCtx, ViewModel parent,
     ObjectClass type,
     Func<IQueryable> qry)
     : base(appCtx, config, fileOpener, tmpService, errorReporter, dataCtx, parent, type, qry)
 {
 }

 public TreeItemInstanceListViewModel(
     IViewModelDependencies appCtx,
     ZetboxConfig config,
     IFileOpener fileOpener,
     ITempFileService tmpService,
     IZetboxContext dataCtx, ViewModel parent,
     Func<IZetboxContext> workingCtxFactory,
     ObjectClass type,
     Func<IQueryable> qry)
     : base(appCtx, config, fileOpener, tmpService, dataCtx, parent, workingCtxFactory, type, qry)
 {
 }