www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Add compile time mutable variable type

reply "Chang Long" <changlon gmail.com> writes:
  I need a type can be change on compile time,  it can be 
immutable or mutable at run time.

For example :
-------------------------------------------------------------------------------
abstract class Template_parameter_Base{
         TypeInto ti;
         string file ;
         size_t  line l;
         string name ;

        this(TypeInto ti, string file, size_t line, string name){
             this.ti = ti ;
             this.file = file ;
            this.line = line ;
            this.name = name ;
         }
}

class Template_parameter(T) : Template_parameter_Base {
        T   value ;
        alias T this;
	void assign(ref T t){
		value = t ;
	}
}

class Template {
          static 
compile_time_mutable(string[Template_parameter_Base])  
template_vars ;

	void assign(string name, string __file__ = __FILE__, size_t 
__line__ =__LINE__, T)(T t) {
		static if( name in template_vars ){
			static parameter = template_vars[name] ;
		} else {
			static parameter = template_vars[name] =  new 
Template_parameter(typeid(T),  __file__, __line__ );
		}
		parameter.assign(t);
	}
	
	string render(){
		// use template_vars comiplate a dynamic link lib ,  and load 
it,  and put the template_vars to it, and run it ,
		// if  dynamic link lib  already exists,  or the templte file 
is not changed, just run it .
	}
}

void main(){
	static tpl = new Template;
	auto  is_login  =  false ;
	tpl.assign!"is_login"( is_login) ) ;
	if( is_login ) {
		tpl.assign!"user"( new User() ) ;
	}
}

-------------------------------------------------------------------------------

Why I need this is because I need to know all parameters at first 
time call Template.render,  but a lot parameter will not be call 
at run time. so I need a type can be changed at compile time.
the new type is just like mutable type at CTFE.
Jun 04 2012
next sibling parent "Chang Long" <changlon gmail.com> writes:
On Tuesday, 5 June 2012 at 01:01:07 UTC, Chang Long wrote:

  I need a type can be change on compile time,  it can be 
 immutable or mutable at run time.

 For example :
 -------------------------------------------------------------------------------
 abstract class Template_parameter_Base{
         TypeInto ti;
         string file ;
         size_t  line l;
         string name ;

        this(TypeInto ti, string file, size_t line, string name){
             this.ti = ti ;
             this.file = file ;
            this.line = line ;
            this.name = name ;
         }
 }

 class Template_parameter(T) : Template_parameter_Base {
        T   value ;
        alias T this;
 	void assign(ref T t){
 		value = t ;
 	}
 }

 class Template {
          static 
 compile_time_mutable(string[Template_parameter_Base])  
 template_vars ;

 	void assign(string name, string __file__ = __FILE__, size_t 
 __line__ =__LINE__, T)(T t) {
 		static if( name in template_vars ){
 			static parameter = template_vars[name] ;
 		} else {
 			static parameter = template_vars[name] =  new 
 Template_parameter(typeid(T),  __file__, __line__ );
 		}
 		parameter.assign(t);
 	}
 	
 	string render(){
 		// use template_vars comiplate a dynamic link lib ,  and load 
 it,  and put the template_vars to it, and run it ,
 		// if  dynamic link lib  already exists,  or the templte file 
 is not changed, just run it .
 	}
 }

 void main(){
 	static tpl = new Template;
 	auto  is_login  =  false ;
 	tpl.assign!"is_login"( is_login) ) ;
 	if( is_login ) {
 		tpl.assign!"user"( new User() ) ;
 	}
 }

 -------------------------------------------------------------------------------

 Why I need this is because I need to know all parameters at 
 first time call Template.render,  but a lot parameter will not 
 be call at run time. so I need a type can be changed at compile 
 time.
 the new type is just like mutable type at CTFE.



this example is more convincing:




abstract class Template_parameter_Base{
         TypeInto ti;
         string file ;
         size_t  line l;
         string name ;

        this(TypeInto ti, string file, size_t line, string name){
             this.ti = ti ;
             this.file = file ;
             this.line = line ;
             this.name = name ;
         }
}

class Template_parameter(T) : Template_parameter_Base {
        T   value ;
        alias T this;
	void assign(ref T t){
		value = t ;
	}
}

class Template {
          static 
compile_time_mutable(Template_parameter_Base[string])  
template_vars ;

	void assign(string name, string __file__ = __FILE__, size_t 
__line__ =__LINE__, T)(T t) {
		static if( name in template_vars ){
			static compile_time_mutable(parameter) = template_vars[name] ;
			static assert( parameter.ti == typeid(T),  "assign var at " ~ 
__file__ ~ " line" ~ __line__ " with type " ~ T.stringof " ~ 
conflict with old parameter at file " ~ parameter.file  ~ " line 
" ~ parameter.line );
		} else {
			static compile_time_mutable(parameter) = template_vars[name] = 
  new Template_parameter(typeid(T),  __file__, __line__ , name );
		}
		// put the value to parameter at run time
		parameter.assign(t);
	}
	
	string render(){
		// use template_vars comiplate a dynamic link lib ,  and load 
it,  and put the template_vars to it, and run it ,
		// if  dynamic link lib  already exists,  or the templte file 
is not changed, just run it .
	}
}

void main(){
	static tpl = new Template;
	auto  is_login  =  false ;
	tpl.assign!"is_login"( is_login) ) ;
	if( is_login ) {
		tpl.assign!"user"( new User() ) ;
	}
	
	auto string switch_user = "new_user_email" ;
	if( switch_user !is null ) {
		tpl.assign!"user"( new User(switch_user) ) ;
	}
	
	tpl.assign!"user"( true )  ; // static assert error
}
Jun 04 2012
prev sibling next sibling parent reply "Chang Long" <changlon gmail.com> writes:
On Tuesday, 5 June 2012 at 01:01:07 UTC, Chang Long wrote:

  I need a type can be change on compile time,  it can be 
 immutable or mutable at run time.

 For example :
 -------------------------------------------------------------------------------
 abstract class Template_parameter_Base{
         TypeInto ti;
         string file ;
         size_t  line l;
         string name ;

        this(TypeInto ti, string file, size_t line, string name){
             this.ti = ti ;
             this.file = file ;
            this.line = line ;
            this.name = name ;
         }
 }

 class Template_parameter(T) : Template_parameter_Base {
        T   value ;
        alias T this;
 	void assign(ref T t){
 		value = t ;
 	}
 }

 class Template {
          static 
 compile_time_mutable(string[Template_parameter_Base])  
 template_vars ;

 	void assign(string name, string __file__ = __FILE__, size_t 
 __line__ =__LINE__, T)(T t) {
 		static if( name in template_vars ){
 			static parameter = template_vars[name] ;
 		} else {
 			static parameter = template_vars[name] =  new 
 Template_parameter(typeid(T),  __file__, __line__ );
 		}
 		parameter.assign(t);
 	}
 	
 	string render(){
 		// use template_vars comiplate a dynamic link lib ,  and load 
 it,  and put the template_vars to it, and run it ,
 		// if  dynamic link lib  already exists,  or the templte file 
 is not changed, just run it .
 	}
 }

 void main(){
 	static tpl = new Template;
 	auto  is_login  =  false ;
 	tpl.assign!"is_login"( is_login) ) ;
 	if( is_login ) {
 		tpl.assign!"user"( new User() ) ;
 	}
 }

 -------------------------------------------------------------------------------

 Why I need this is because I need to know all parameters at 
 first time call Template.render,  but a lot parameter will not 
 be call at run time. so I need a type can be changed at compile 
 time.
 the new type is just like mutable type at CTFE.




The previous two example is not correct, please see this one:





abstract class Template_parameter_Base{
         TypeInto ti;
         string file ;
         size_t  line l;
         string name ;

        this(TypeInto ti, string file, size_t line, string name){
             this.ti = ti ;
             this.file = file ;
             this.line = line ;
             this.name = name ;
         }
}

class Template_parameter(T) : Template_parameter_Base {
        T   value ;
        alias T this;
	void assign(ref T t){
		value = t ;
	}
}

class Template_Engine {
	string name ;
	Template_parameter_Base[string] parameters ;
	void this(string name) {
		this.name = name ;
	}
}


class Template (string name) {
	
	static compile_time_mutable(Template_Engine)  engine = new 
Template_Engine(name) ;
	
	void assign(string name, string __file__ = __FILE__, size_t 
__line__ =__LINE__, T)(T t) {
		static if( name in engine.parameters ){
			static compile_time_mutable(parameter) = 
engine.parameters[name] ;
			static assert( parameter.ti == typeid(T),  "assign var at " ~ 
__file__ ~ " line" ~ __line__ " with type " ~ T.stringof " ~ 
conflict with old parameter at file " ~ parameter.file  ~ " line 
" ~ parameter.line );
		} else {
			static compile_time_mutable(parameter) = 
engine.parameters[name] =  new Template_parameter(typeid(T),  
__file__, __line__ , name );
		}
		// put the value to parameter at run time
		parameter.assign(t);
	}
	
	string render(){
		// use the engine.parameters can know all parameter type 
information
		// use template_vars comiplate a dynamic link lib ,  and load 
it,  and put the template_vars to it, and run it ,
		// if  dynamic link lib  already exists,  or the templte file 
is not changed, just run it .
	}
}

void main(){
	static tpl = new Template!"home_page" ;
	auto  is_login  =  false ;
	tpl.assign!"is_login"( is_login) ) ;
	if( is_login ) {
		tpl.assign!"user"( new User() ) ;
	}
	
	auto string switch_user = "new_user_email" ;
	if( switch_user !is null ) {
		tpl.assign!"user"( new User(switch_user) ) ;
	}
	
	tpl.assign!"user"( true )  ; // static assert error
}
Jun 04 2012
parent =?UTF-8?B?QWxpIMOHZWhyZWxp?= <acehreli yahoo.com> writes:
On 06/04/2012 06:22 PM, Chang Long wrote:


 The previous two example is not correct, please see this one:



Your post sounds interesting but there are lots of errors:


 size_t line l;  <-- ERROR




 void this(string name) { <-- ERROR



etc. Can you actually compile that code?

It would be better if you can present your question with less code.

Ali
Jun 04 2012
prev sibling parent "Chang Long" <changlon gmail.com> writes:
On Tuesday, 5 June 2012 at 05:39:34 UTC, Ali Çehreli wrote:

 On 06/04/2012 06:22 PM, Chang Long wrote:


 The previous two example is not correct, please see this one:



 Your post sounds interesting but there are lots of errors:


 size_t line l;  <-- ERROR




 void this(string name) { <-- ERROR



 etc. Can you actually compile that code?

 It would be better if you can present your question with less 
 code.

 Ali



-----------------------------------------------------------
abstract class Template_parameter_Base{
         TypeInto ti;
         string name ;
         this(TypeInto ti, string name) {
             this.ti = ti ;
             this.name = name ;
         }
}
class Template_parameter(T) : Template_parameter_Base {
	T   value ;
  	alias value this;
	void assign(ref T t){
		value = t ;
	}
}
class Template_Engine {
	string name ;
	Template_parameter_Base[string] parameters ;
	void this(string name) {
		this.name = name ;
	}
}
class Template(string name) {
	static compile_time_mutable(Template_Engine)  engine = new 
Template_Engine!name ;
	void assign(string name, T)(ref T t){
		static if(name in vars) {
			static const parameter	= cast(Template_parameter!T) 
engine.parameters[name];
			static assert( parameter.ti == typeid(T) );
		} else {
			static const parameter	=  new Template_parameter!T(typeid(T), 
name) ;
			static engine.parameters[name]		=  parameter ;
		}
		parameter.assign(t);
	}
}
void main(){
	static tpl = new Template!"home_page" ;
	auto  is_login  =  false ;
	tpl.assign!"is_login"( is_login) ) ;
	if( is_login ) {
		tpl.assign!"user"( new User() ) ;
	}
	
	auto string switch_user = "new_user_email" ;
	if( switch_user !is null ) {
		tpl.assign!"user"( new User(switch_user) ) ;
	}
	
	tpl.assign!"user"( true )  ; // static assert error
}
-----------------------------------------------------------

After think what is done,  a better way is put the 
Template_parameter on the annotation data section.

some things like this:
class Template_Engine(string name) {
      static this_ti =  typeid( typeof(this) ) ;
      void assign(string name, T)(ref T t){
             static const parameter = new Template_parameter!(T, 
name) ;
             ti.createAnnotation("Template_Engine_Parameter", 
parameter);
             parameter.assign(t);
       }
       void render(){
            auto parameters =  
this_ti.getParametersByName("Template_Engine_Parameter") ;
            // compile template to dynamic link library by 
template file and parameters
      }
}
Jun 04 2012