Compare commits

...

22 Commits

Author SHA1 Message Date
Tomasz Sowa 41ac172b91 remove some old values from Type enum 2022-04-12 19:10:10 +02:00
Tomasz Sowa b9f1fa913e fixed: set find_helper.found=true in CallSpaceWrapper() and CallSpace() 2021-12-09 13:30:09 +01:00
Tomasz Sowa 973f05cc08 some work on iterating through tables 2021-11-24 13:19:27 +01:00
Tomasz Sowa 86d0b7d886 changed the semantic of [for ...] loops, we have 'val' keyword now for referencing child objects
sample:
[for mylist]
  [mylist.val]
[end]
before we use 'this' but only for POD simple types, now we use 'val' for all types
2021-11-23 19:40:52 +01:00
Tomasz Sowa 943026a3ac I forget to add modified files to previous commit
(added support for Space tables, removed Models class)
2021-11-22 15:44:37 +01:00
Tomasz Sowa c2c12d55d0 added support for Space tables
removed Models class
2021-11-22 15:43:08 +01:00
Tomasz Sowa a7656d5ccd added space values 2021-11-21 21:08:06 +01:00
Tomasz Sowa 46bc5c35a1 added "add" methods with vector/list of models to Vars 2021-11-20 22:02:18 +01:00
Tomasz Sowa 7caddeedbf set *find_helper.result if a child object was found 2021-11-09 00:23:43 +01:00
Tomasz Sowa ac66a6649d some work on iterating through collection of models - not working yet 2021-11-08 00:41:36 +01:00
Tomasz Sowa 2f140686d7 let filters make use of Var<> objects 2021-11-06 19:20:11 +01:00
Tomasz Sowa e2a8729a2f Env<>::in is Var<> now and we pass last result as in into next field 2021-11-06 19:07:39 +01:00
Tomasz Sowa bb0cc59eca if a ezc function returns another function we should evaluate it 2021-11-05 22:23:22 +01:00
Tomasz Sowa b8a9217429 use new FindHelper struct in places where fields, field_index, parameters variables were used 2021-11-05 09:34:05 +01:00
Tomasz Sowa 6d79cdb2fc instead of morm::Wrapper let the Var<> has a child's map 2021-10-27 14:23:48 +02:00
Tomasz Sowa a61fd2dcd0 mark a new function FindVariable() 2021-10-25 21:33:21 +02:00
Tomasz Sowa 03a76d35ad - Var is a template now: Var<StreamType>
- removed using cache for a while
- Generator: instead of blocks, functions, objects we have now only variables
  (work in progress)
2021-10-20 08:23:45 +02:00
Tomasz Sowa dfb8e5da78 Merge commit 'd8692f6ed56a8bb1bcdd1117aef7df69ec1c39aa' into types
"index" and "index-one" options for space tables
2021-09-23 14:09:23 +02:00
Tomasz Sowa 3c969ac5c6 added: "this" virtual field for a table (only if the next field is not an object)
cherry picked from b047a10e8d
2021-09-23 04:11:20 +02:00
Tomasz Sowa d9804f05aa added Vars<> container 2021-09-14 00:31:50 +02:00
Tomasz Sowa 09beafeab7 template FunInfo<> renamed to Env<> 2021-08-29 20:55:15 +02:00
Tomasz Sowa e826ba34ae start working on types for Ezc
- now Var struct has some basic types (string, bool, stream, model, etc.)
- Generator doesn't directly put output to out_stream but to Var& result
2021-08-29 20:35:15 +02:00
16 changed files with 2705 additions and 1063 deletions

View File

@ -3,33 +3,59 @@
blocks.o: blocks.h item.h cache.h functions.h ../../pikotools/src/utf8/utf8.h
blocks.o: ../../pikotools/src/textstream/stream.h
blocks.o: ../../pikotools/src/utf8/utf8_templates.h
blocks.o: ../../pikotools/src/utf8/utf8_private.h funinfo.h objects.h
blocks.o: ../../pikotools/src/utf8/utf8_private.h env.h var.h
blocks.o: ../../pikotools/src/date/date.h
blocks.o: ../../pikotools/src/convert/inttostr.h
blocks.o: ../../pikotools/src/textstream/textstream.h
blocks.o: ../../pikotools/src/textstream/stream.h
blocks.o: ../../pikotools/src/space/space.h
blocks.o: ../../pikotools/src/textstream/types.h
blocks.o: ../../pikotools/src/membuffer/membuffer.h
blocks.o: ../../pikotools/src/textstream/types.h
blocks.o: ../../pikotools/src/utf8/utf8_stream.h objects.h
cache.o: cache.h item.h functions.h ../../pikotools/src/utf8/utf8.h
cache.o: ../../pikotools/src/textstream/stream.h
cache.o: ../../pikotools/src/utf8/utf8_templates.h
cache.o: ../../pikotools/src/utf8/utf8_private.h funinfo.h objects.h blocks.h
cache.o: ../../pikotools/src/utf8/utf8_private.h env.h var.h
cache.o: ../../pikotools/src/date/date.h
cache.o: ../../pikotools/src/convert/inttostr.h
cache.o: ../../pikotools/src/textstream/textstream.h
cache.o: ../../pikotools/src/textstream/stream.h
cache.o: ../../pikotools/src/space/space.h
cache.o: ../../pikotools/src/textstream/types.h
cache.o: ../../pikotools/src/membuffer/membuffer.h
cache.o: ../../pikotools/src/textstream/types.h
cache.o: ../../pikotools/src/utf8/utf8_stream.h objects.h blocks.h
item.o: item.h
models.o: models.h
pattern.o: pattern.h item.h cache.h functions.h
pattern.o: ../../pikotools/src/utf8/utf8.h
pattern.o: ../../pikotools/src/textstream/stream.h
pattern.o: ../../pikotools/src/utf8/utf8_templates.h
pattern.o: ../../pikotools/src/utf8/utf8_private.h funinfo.h objects.h
pattern.o: blocks.h
pattern.o: ../../pikotools/src/utf8/utf8_private.h env.h var.h
pattern.o: ../../pikotools/src/date/date.h
pattern.o: ../../pikotools/src/convert/inttostr.h
pattern.o: ../../pikotools/src/textstream/textstream.h
pattern.o: ../../pikotools/src/textstream/stream.h
pattern.o: ../../pikotools/src/space/space.h
pattern.o: ../../pikotools/src/textstream/types.h
pattern.o: ../../pikotools/src/membuffer/membuffer.h
pattern.o: ../../pikotools/src/textstream/types.h
pattern.o: ../../pikotools/src/utf8/utf8_stream.h objects.h blocks.h
patternparser.o: patternparser.h blocks.h item.h cache.h functions.h
patternparser.o: ../../pikotools/src/utf8/utf8.h
patternparser.o: ../../pikotools/src/textstream/stream.h
patternparser.o: ../../pikotools/src/utf8/utf8_templates.h
patternparser.o: ../../pikotools/src/utf8/utf8_private.h funinfo.h objects.h
patternparser.o: pattern.h ../../pikotools/src/log/log.h
patternparser.o: ../../pikotools/src/utf8/utf8_private.h env.h var.h
patternparser.o: ../../pikotools/src/date/date.h
patternparser.o: ../../pikotools/src/convert/inttostr.h
patternparser.o: ../../pikotools/src/textstream/textstream.h
patternparser.o: ../../pikotools/src/textstream/stream.h
patternparser.o: ../../pikotools/src/space/space.h
patternparser.o: ../../pikotools/src/textstream/types.h
patternparser.o: ../../pikotools/src/convert/inttostr.h
patternparser.o: ../../pikotools/src/date/date.h
patternparser.o: ../../pikotools/src/membuffer/membuffer.h
patternparser.o: ../../pikotools/src/textstream/types.h
patternparser.o: ../../pikotools/src/utf8/utf8_stream.h objects.h pattern.h
patternparser.o: ../../pikotools/src/log/log.h
patternparser.o: ../../pikotools/src/log/filelog.h
patternparser.o: ../../pikotools/src/convert/convert.h
patternparser.o: ../../pikotools/src/convert/inttostr.h

View File

@ -1 +1 @@
o = blocks.o cache.o item.o models.o pattern.o patternparser.o
o = blocks.o cache.o item.o pattern.o patternparser.o

View File

@ -5,7 +5,7 @@
*/
/*
* Copyright (c) 2014, Tomasz Sowa
* Copyright (c) 2014-2021, Tomasz Sowa
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -90,10 +90,12 @@ void Blocks::ClearCache()
void Blocks::CacheBlocks(Blocks & blocks)
{
/*
BlocksTable::iterator i = blocks_tab.begin();
for( ; i != blocks_tab.end() ; ++i)
Cache(blocks, i->second);
*/
}

View File

@ -43,7 +43,7 @@
namespace Ezc
{
/*
void Cache(Blocks & blocks, Item::Function & function)
{
function.item_block = 0;
@ -69,7 +69,7 @@ void Cache(Blocks & blocks, Item & item)
for(size_t i=0; i < item.item_tab.size() ; ++i)
Cache(blocks, *item.item_tab[i]);
}
*/

View File

@ -51,7 +51,7 @@ namespace Ezc
class Blocks;
/*
template<class StreamType>
void Cache(Functions<StreamType> & fun, Item::Function & function)
{
@ -114,7 +114,7 @@ void Cache(Objects<StreamType> & objects, Item & item)
for(size_t i=0; i < item.item_tab.size() ; ++i)
Cache(objects, *item.item_tab[i]);
}
*/
} // namespace Ezc

View File

@ -5,7 +5,7 @@
*/
/*
* Copyright (c) 2007-2016, Tomasz Sowa
* Copyright (c) 2007-2021, Tomasz Sowa
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -36,42 +36,23 @@
*/
#ifndef headerfile_ezc_funinfo
#define headerfile_ezc_funinfo
#ifndef headerfile_ezc_env
#define headerfile_ezc_env
#include <vector>
#include <map>
#include "item.h"
#include "modelcontainerwrapper.h"
#include "var.h"
namespace Ezc
{
/*
a variable
*/
struct Var
{
/*
* if true then means 'str' is a function name and should be called (res is ignored)
*
* if false then means 'str' is a string value and res is a boolean value
*/
bool is_function;
std::wstring str; // a string value
bool res; // a boolean value
Var()
{
res = false;
is_function = false;
}
};
typedef std::map<std::wstring, Var> Vars;
//typedef std::map<std::wstring, Var<StreamType>> Vars;
@ -143,30 +124,27 @@ struct Stack
};
// !! IMPROVE ME
// the name is bad
// may it should be called Env (environment) or FunEnv
template<class StreamType>
struct FunInfo
struct Env
{
// a result consists of a string and a boolean value
// output stream
// an alias to res.stream
StreamType & out;
// return value from a user's function (default false if not set directly by the function)
bool res;
// result
Var<StreamType> & res;
// table of parameters
// the table can be empty
std::vector<Var> & params;
std::vector<Var<StreamType>> & params;
// the first parameter
// you can always use it even if there are not any parameters (params is empty)
// in such a way the reference points to an empty string
const std::wstring & par;
//const std::wstring & par;
// an input stream used in [filter] statement
// if there is other statement than [filter] then this is an empty stream
const StreamType & in;
// and when methods/functions are chained
Var<StreamType> & in;
// indicates that this function is from [for ...] statement
bool is_for;
@ -209,21 +187,18 @@ struct FunInfo
// arguments: output_stream, table_of_parameters, the_first_parameter
FunInfo(StreamType & o,
std::vector<Var> & pars,
const std::wstring & first_par,
const StreamType & input_stream,
Stack & s,
const Item & item_) : out(o), params(pars), par(first_par), in(input_stream), stack(s), item(item_)
Env(Var<StreamType> & result,
std::vector<Var<StreamType>> & pars,
Var<StreamType> & input_stream,
Stack & s,
const Item & item_) : out(result.stream), res(result), params(pars), in(input_stream), stack(s), item(item_)
{
Clear();
clear();
}
void Clear()
void clear()
{
res = false; // result is false by default
is_for = false;
is_if = false;
is_if_def = false;
@ -231,70 +206,10 @@ struct FunInfo
is_normal = false;
is_filter = false;
iter = 0;
stack_tab = 0;
stack_tab = nullptr;
stack_index = 0;
}
/*
* CHECK ME can it be done only for [for] statements?
*
* can return a null pointer if there is no such an item on the stack
*
* add a function with const wchar_t *
*/
Stack * FindLastFor(const std::wstring & name)
{
for(size_t i = stack_index ; i > 0 ; --i)
{
if( stack_tab[i-1].is_for && stack_tab[i-1].item->has_function )
{
if( stack_tab[i-1].item->function.name == name )
{
return &stack_tab[i-1];
}
}
}
return 0;
}
Stack * FindLastFor(const std::wstring & name, const std::wstring & postfix)
{
for(size_t i = stack_index ; i > 0 ; --i)
{
if( stack_tab[i-1].is_for && stack_tab[i-1].item->has_function )
{
if( stack_tab[i-1].item->function.name == name && stack_tab[i-1].item->function.postfix == postfix )
{
return &stack_tab[i-1];
}
}
}
return 0;
}
template<class FunUserObject>
FunUserObject * FindUserObject(const std::wstring & function_name, Stack ** ezc_stack = 0)
{
Stack * stack;
if( item.has_function && item.function.is_function )
stack = FindLastFor(function_name, item.function.postfix);
else
stack = FindLastFor(function_name);
if( ezc_stack )
*ezc_stack = stack;
if( stack && stack->fun_data )
return dynamic_cast<FunUserObject*>(stack->fun_data);
return 0;
}
};

View File

@ -5,7 +5,7 @@
*/
/*
* Copyright (c) 2007-2015, Tomasz Sowa
* Copyright (c) 2007-2021, Tomasz Sowa
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -40,7 +40,7 @@
#include <map>
#include "utf8/utf8.h"
#include "funinfo.h"
#include "env.h"
@ -56,7 +56,7 @@ class Functions
{
public:
typedef void (*UserFunction)(FunInfo<StreamType> &);
typedef void (*UserFunction)(Env<StreamType> &);
typedef std::map<std::wstring, UserFunction> FunctionsTable;
typedef typename FunctionsTable::iterator Iterator;

File diff suppressed because it is too large Load Diff

View File

@ -5,7 +5,7 @@
*/
/*
* Copyright (c) 2007-2018, Tomasz Sowa
* Copyright (c) 2007-2021, Tomasz Sowa
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -168,10 +168,10 @@ Item::~Item()
void Item::ClearCache(Item::Function & function)
{
function.base_obj = 0;
function.method_index = -1;
function.fun_cache = 0;
function.item_block = 0;
// function.base_obj = 0;
// function.method_index = -1;
// function.fun_cache = 0;
// function.item_block = 0;
for(size_t i=0 ; i<function.parameters.size() ; ++i)
ClearCache(*function.parameters[i]);

View File

@ -69,20 +69,16 @@ struct Item
// e.g. [my_function:my_postfix]
std::vector<Function*> parameters; // if is_function is true then it is a function and can have 'parameters'
// if is_function is empty then 'parameters' is empty too
void * fun_cache; // only valid if is_function is true
Item * item_block;
void * base_obj;
int method_index;
//void * fun_cache; // only valid if is_function is true
//Item * item_block;
int arg; // used if name is numeric (if no then is equal -1)
Function()
{
is_function = false;
fun_cache = 0;
item_block = 0;
base_obj = 0;
method_index = -1;
//fun_cache = 0;
//item_block = 0;
arg = -1;
}
@ -102,10 +98,8 @@ struct Item
name = f.name;
fields = f.fields;
postfix = f.postfix;
fun_cache = f.fun_cache;
item_block = f.item_block;
base_obj = f.base_obj;
method_index = f.method_index;
//fun_cache = f.fun_cache;
//item_block = f.item_block;
arg = f.arg;
for(size_t i=0 ; i<f.parameters.size() ; ++i)
@ -130,10 +124,8 @@ struct Item
parameters.clear();
name.clear();
postfix.clear();
fun_cache = 0;
item_block = 0;
base_obj = 0;
method_index = -1;
//fun_cache = 0;
//item_block = 0;
arg = -1;
is_function = false;
}

View File

@ -1,133 +0,0 @@
/*
* This file is a part of EZC -- Easy templating in C++ library
* and is distributed under the BSD 3-Clause licence.
* Author: Tomasz Sowa <t.sowa@ttmath.org>
*/
/*
* Copyright (c) 2021, Tomasz Sowa
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name Tomasz Sowa nor the names of contributors to this
* project may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "models.h"
#ifdef EZC_HAS_MORM_LIBRARY
namespace Ezc
{
Models::Models()
{
}
Models::~Models()
{
Clear();
}
void Models::Clear()
{
models_map.clear();
}
void Models::Add(const std::wstring & name, morm::Model & model)
{
morm::Wrapper wrapper;
wrapper.model = &model;
models_map[name] = wrapper;
}
void Models::Add(const std::wstring & name, morm::Model * model)
{
morm::Wrapper wrapper;
wrapper.model = model;
models_map[name] = wrapper;
}
void Models::Add(const std::wstring & name, pt::Space & space)
{
morm::Wrapper wrapper;
wrapper.space_wrapper = new morm::SpaceWrapper(&space);
models_map[name] = wrapper;
}
void Models::Add(const std::wstring & name, pt::Space * space)
{
morm::Wrapper wrapper;
wrapper.space_wrapper = new morm::SpaceWrapper(space);
models_map[name] = wrapper;
}
void Models::Add(const std::wstring & name, pt::Date & date)
{
morm::Wrapper wrapper;
wrapper.date = &date;
models_map[name] = wrapper;
}
void Models::Add(const std::wstring & name, pt::Date * date)
{
morm::Wrapper wrapper;
wrapper.date = date;
models_map[name] = wrapper;
}
morm::Wrapper * Models::Find(const std::wstring & name)
{
auto iterator = models_map.find(name);
if( iterator != models_map.end() )
{
return &iterator->second;
}
return nullptr;
}
}
#endif

View File

@ -1,148 +0,0 @@
/*
* This file is a part of EZC -- Easy templating in C++ library
* and is distributed under the BSD 3-Clause licence.
* Author: Tomasz Sowa <t.sowa@ttmath.org>
*/
/*
* Copyright (c) 2021, Tomasz Sowa
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name Tomasz Sowa nor the names of contributors to this
* project may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef headerfile_ezc_models
#define headerfile_ezc_models
#ifdef EZC_HAS_MORM_LIBRARY
#include "wrapper.h"
#include "funinfo.h"
#include "space/space.h"
namespace Ezc
{
class Models
{
public:
Models();
~Models();
void Add(const std::wstring & name, morm::Model & model);
void Add(const std::wstring & name, morm::Model * model);
void Add(const std::wstring & name, pt::Space & space);
void Add(const std::wstring & name, pt::Space * space);
void Add(const std::wstring & name, pt::Date & space);
void Add(const std::wstring & name, pt::Date * space);
template<typename VectorType>
void Add(const std::wstring & name, std::vector<VectorType> & container)
{
morm::Wrapper wrapper;
wrapper.model_container_wrapper = new morm::ModelWrapperVector<VectorType>(&container);
models_map[name] = wrapper;
}
template<typename VectorType>
void Add(const std::wstring & name, std::vector<VectorType> * container)
{
morm::Wrapper wrapper;
wrapper.model_container_wrapper = new morm::ModelWrapperVector<VectorType>(container);
models_map[name] = wrapper;
}
template<typename VectorType>
void Add(const std::wstring & name, std::vector<VectorType*> & container)
{
morm::Wrapper wrapper;
wrapper.model_container_wrapper = new morm::ModelWrapperVectorPointer<VectorType>(&container);
models_map[name] = wrapper;
}
template<typename VectorType>
void Add(const std::wstring & name, std::vector<VectorType*> * container)
{
morm::Wrapper wrapper;
wrapper.model_container_wrapper = new morm::ModelWrapperVectorPointer<VectorType>(container);
models_map[name] = wrapper;
}
template<typename ListType>
void Add(const std::wstring & name, std::list<ListType> & container)
{
morm::Wrapper wrapper;
wrapper.model_container_wrapper = new morm::ModelWrapperList<ListType>(&container);
models_map[name] = wrapper;
}
template<typename ListType>
void Add(const std::wstring & name, std::list<ListType> * container)
{
morm::Wrapper wrapper;
wrapper.model_container_wrapper = new morm::ModelWrapperList<ListType>(container);
models_map[name] = wrapper;
}
template<typename ListType>
void Add(const std::wstring & name, std::list<ListType*> & container)
{
morm::Wrapper wrapper;
wrapper.model_container_wrapper = new morm::ModelWrapperListPointer<ListType>(&container);
models_map[name] = wrapper;
}
template<typename ListType>
void Add(const std::wstring & name, std::list<ListType*> * container)
{
morm::Wrapper wrapper;
wrapper.model_container_wrapper = new morm::ModelWrapperListPointer<ListType>(container);
models_map[name] = wrapper;
}
morm::Wrapper * Find(const std::wstring & name);
void Clear();
protected:
std::map<std::wstring, morm::Wrapper> models_map;
};
}
#endif
#endif

View File

@ -5,7 +5,7 @@
*/
/*
* Copyright (c) 2015, Tomasz Sowa
* Copyright (c) 2015-2021, Tomasz Sowa
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -72,7 +72,7 @@ public:
/*
*
*/
virtual void CallFun(int fun_index, FunInfo<StreamType> &) = 0;
virtual void CallFun(int fun_index, Env<StreamType> &) = 0;
/*

View File

@ -5,7 +5,7 @@
*/
/*
* Copyright (c) 2007-2014, Tomasz Sowa
* Copyright (c) 2007-2021, Tomasz Sowa
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -60,7 +60,7 @@ void Pattern::Clear()
void Pattern::CacheBlocks(Blocks & blocks)
{
Cache(blocks, item_root);
//Cache(blocks, item_root);
}

1037
src/var.h Normal file

File diff suppressed because it is too large Load Diff

493
src/vars.h Normal file
View File

@ -0,0 +1,493 @@
/*
* This file is a part of EZC -- Easy templating in C++ library
* and is distributed under the BSD 3-Clause licence.
* Author: Tomasz Sowa <t.sowa@ttmath.org>
*/
/*
* Copyright (c) 2021, Tomasz Sowa
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name Tomasz Sowa nor the names of contributors to this
* project may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef headerfile_ezc_vars
#define headerfile_ezc_vars
#include "var.h"
#include "utf8/utf8.h"
#include "env.h"
#include <string>
#include <map>
#include <list>
namespace Ezc
{
// rename to something like Object? or a better name?
template<typename StreamType>
class Vars
{
public:
typedef void (*UserFunction)(Env<StreamType> &);
Var<StreamType> & add(const char * name);
Var<StreamType> & add(const wchar_t * name);
Var<StreamType> & add(const std::string & name);
Var<StreamType> & add(const std::wstring & name);
void add(const char * name, const Var<StreamType> & var);
void add(const wchar_t * name, const Var<StreamType> & var);
void add(const std::string & name, const Var<StreamType> & var);
void add(const std::wstring & name, const Var<StreamType> & var);
Var<StreamType> & add(const char * name, UserFunction user_function);
Var<StreamType> & add(const wchar_t * name, UserFunction user_function);
Var<StreamType> & add(const std::string & name, UserFunction user_function);
Var<StreamType> & add(const std::wstring & name, UserFunction user_function);
Var<StreamType> & add(const char * name, morm::Model & model);
Var<StreamType> & add(const wchar_t * name, morm::Model & model);
Var<StreamType> & add(const std::string & name, morm::Model & model);
Var<StreamType> & add(const std::wstring & name, morm::Model & model);
template<typename ModelType>
Var<StreamType> & add(const char * name, std::vector<ModelType> & model_container);
template<typename ModelType>
Var<StreamType> & add(const wchar_t * name, std::vector<ModelType> & model_container);
template<typename ModelType>
Var<StreamType> & add(const std::string & name, std::vector<ModelType> & model_container);
template<typename ModelType>
Var<StreamType> & add(const std::wstring & name, std::vector<ModelType> & model_container);
template<typename ModelType>
Var<StreamType> & add(const char * name, std::list<ModelType> & model_container);
template<typename ModelType>
Var<StreamType> & add(const wchar_t * name, std::list<ModelType> & model_container);
template<typename ModelType>
Var<StreamType> & add(const std::string & name, std::list<ModelType> & model_container);
template<typename ModelType>
Var<StreamType> & add(const std::wstring & name, std::list<ModelType> & model_container);
template<typename ModelType>
Var<StreamType> & add(const char * name, std::vector<ModelType*> & model_container);
template<typename ModelType>
Var<StreamType> & add(const wchar_t * name, std::vector<ModelType*> & model_container);
template<typename ModelType>
Var<StreamType> & add(const std::string & name, std::vector<ModelType*> & model_container);
template<typename ModelType>
Var<StreamType> & add(const std::wstring & name, std::vector<ModelType*> & model_container);
template<typename ModelType>
Var<StreamType> & add(const char * name, std::list<ModelType*> & model_container);
template<typename ModelType>
Var<StreamType> & add(const wchar_t * name, std::list<ModelType*> & model_container);
template<typename ModelType>
Var<StreamType> & add(const std::string & name, std::list<ModelType*> & model_container);
template<typename ModelType>
Var<StreamType> & add(const std::wstring & name, std::list<ModelType*> & model_container);
Var<StreamType> * find(const char * name) const;
Var<StreamType> * find(const wchar_t * name) const;
Var<StreamType> * find(const std::string & name) const;
Var<StreamType> * find(const std::wstring & name) const;
private:
typedef std::list<Var<StreamType>> VarList;
VarList var_list;
typedef std::map<std::wstring, Var<StreamType>*> VarMap;
VarMap var_map;
};
template<typename StreamType>
Var<StreamType> & Vars<StreamType>::add(const char * name)
{
std::wstring name_wide;
pt::utf8_to_wide(name, name_wide);
add(name_wide);
}
template<typename StreamType>
Var<StreamType> & Vars<StreamType>::add(const wchar_t * name)
{
std::wstring name_str(name);
return add(name_str);
}
template<typename StreamType>
Var<StreamType> & Vars<StreamType>::add(const std::string & name)
{
std::wstring name_wide;
pt::utf8_to_wide(name, name_wide);
return add(name_wide);
}
template<typename StreamType>
Var<StreamType> & Vars<StreamType>::add(const std::wstring & name)
{
auto i = var_map.insert(std::make_pair(name, nullptr));
if( i.second )
{
Var<StreamType> & var = var_list.emplace_back();
i.first->second = &var;
}
i.first->second->clear();
return *(i.first->second);
}
template<typename StreamType>
void Vars<StreamType>::add(const char * name, const Var<StreamType> & var)
{
std::wstring name_wide;
pt::utf8_to_wide(name, name_wide);
add(name_wide, var);
}
template<typename StreamType>
void Vars<StreamType>::add(const wchar_t * name, const Var<StreamType> & var)
{
std::wstring name_str(name);
add(name_str, var);
}
template<typename StreamType>
void Vars<StreamType>::add(const std::string & name, const Var<StreamType> & var)
{
std::wstring name_wide;
pt::utf8_to_wide(name, name_wide);
add(name_wide, var);
}
template<typename StreamType>
void Vars<StreamType>::add(const std::wstring & name, const Var<StreamType> & var)
{
var_list.push_back(var);
var_map[name] = &var_list.back();
}
template<typename StreamType>
Var<StreamType> & Vars<StreamType>::add(const char * name, UserFunction user_function)
{
Var<StreamType> & var = add(name);
var.set(user_function);
return var;
}
template<typename StreamType>
Var<StreamType> & Vars<StreamType>::add(const wchar_t * name, UserFunction user_function)
{
Var<StreamType> & var = add(name);
var.set(user_function);
return var;
}
template<typename StreamType>
Var<StreamType> & Vars<StreamType>::add(const std::string & name, UserFunction user_function)
{
Var<StreamType> & var = add(name);
var.set(user_function);
return var;
}
template<typename StreamType>
Var<StreamType> & Vars<StreamType>::add(const std::wstring & name, UserFunction user_function)
{
Var<StreamType> & var = add(name);
var.set(user_function);
return var;
}
template<typename StreamType>
Var<StreamType> & Vars<StreamType>::add(const char * name, morm::Model & model)
{
Var<StreamType> & var = add(name);
var.set(model);
return var;
}
template<typename StreamType>
Var<StreamType> & Vars<StreamType>::add(const wchar_t * name, morm::Model & model)
{
Var<StreamType> & var = add(name);
var.set(model);
return var;
}
template<typename StreamType>
Var<StreamType> & Vars<StreamType>::add(const std::string & name, morm::Model & model)
{
Var<StreamType> & var = add(name);
var.set(model);
return var;
}
template<typename StreamType>
Var<StreamType> & Vars<StreamType>::add(const std::wstring & name, morm::Model & model)
{
Var<StreamType> & var = add(name);
var.set(model);
return var;
}
template<typename StreamType>
template<typename ModelType>
Var<StreamType> & Vars<StreamType>::add(const char * name, std::vector<ModelType> & model_container)
{
Var<StreamType> & var = add(name);
var.set(model_container);
return var;
}
template<typename StreamType>
template<typename ModelType>
Var<StreamType> & Vars<StreamType>::add(const wchar_t * name, std::vector<ModelType> & model_container)
{
Var<StreamType> & var = add(name);
var.set(model_container);
return var;
}
template<typename StreamType>
template<typename ModelType>
Var<StreamType> & Vars<StreamType>::add(const std::string & name, std::vector<ModelType> & model_container)
{
Var<StreamType> & var = add(name);
var.set(model_container);
return var;
}
template<typename StreamType>
template<typename ModelType>
Var<StreamType> & Vars<StreamType>::add(const std::wstring & name, std::vector<ModelType> & model_container)
{
Var<StreamType> & var = add(name);
var.set(model_container);
return var;
}
template<typename StreamType>
template<typename ModelType>
Var<StreamType> & Vars<StreamType>::add(const char * name, std::list<ModelType> & model_container)
{
Var<StreamType> & var = add(name);
var.set(model_container);
return var;
}
template<typename StreamType>
template<typename ModelType>
Var<StreamType> & Vars<StreamType>::add(const wchar_t * name, std::list<ModelType> & model_container)
{
Var<StreamType> & var = add(name);
var.set(model_container);
return var;
}
template<typename StreamType>
template<typename ModelType>
Var<StreamType> & Vars<StreamType>::add(const std::string & name, std::list<ModelType> & model_container)
{
Var<StreamType> & var = add(name);
var.set(model_container);
return var;
}
template<typename StreamType>
template<typename ModelType>
Var<StreamType> & Vars<StreamType>::add(const std::wstring & name, std::list<ModelType> & model_container)
{
Var<StreamType> & var = add(name);
var.set(model_container);
return var;
}
template<typename StreamType>
template<typename ModelType>
Var<StreamType> & Vars<StreamType>::add(const char * name, std::vector<ModelType*> & model_container)
{
Var<StreamType> & var = add(name);
var.set(model_container);
return var;
}
template<typename StreamType>
template<typename ModelType>
Var<StreamType> & Vars<StreamType>::add(const wchar_t * name, std::vector<ModelType*> & model_container)
{
Var<StreamType> & var = add(name);
var.set(model_container);
return var;
}
template<typename StreamType>
template<typename ModelType>
Var<StreamType> & Vars<StreamType>::add(const std::string & name, std::vector<ModelType*> & model_container)
{
Var<StreamType> & var = add(name);
var.set(model_container);
return var;
}
template<typename StreamType>
template<typename ModelType>
Var<StreamType> & Vars<StreamType>::add(const std::wstring & name, std::vector<ModelType*> & model_container)
{
Var<StreamType> & var = add(name);
var.set(model_container);
return var;
}
template<typename StreamType>
template<typename ModelType>
Var<StreamType> & Vars<StreamType>::add(const char * name, std::list<ModelType*> & model_container)
{
Var<StreamType> & var = add(name);
var.set(model_container);
return var;
}
template<typename StreamType>
template<typename ModelType>
Var<StreamType> & Vars<StreamType>::add(const wchar_t * name, std::list<ModelType*> & model_container)
{
Var<StreamType> & var = add(name);
var.set(model_container);
return var;
}
template<typename StreamType>
template<typename ModelType>
Var<StreamType> & Vars<StreamType>::add(const std::string & name, std::list<ModelType*> & model_container)
{
Var<StreamType> & var = add(name);
var.set(model_container);
return var;
}
template<typename StreamType>
template<typename ModelType>
Var<StreamType> & Vars<StreamType>::add(const std::wstring & name, std::list<ModelType*> & model_container)
{
Var<StreamType> & var = add(name);
var.set(model_container);
return var;
}
template<typename StreamType>
Var<StreamType> * Vars<StreamType>::find(const char * name) const
{
std::wstring name_wide;
pt::utf8_to_wide(name, name_wide);
return find(name_wide);
}
template<typename StreamType>
Var<StreamType> * Vars<StreamType>::find(const wchar_t * name) const
{
typename VarMap::const_iterator i = var_map.find(name);
if( i != var_map.end() )
{
return i->second;
}
return nullptr;
}
template<typename StreamType>
Var<StreamType> * Vars<StreamType>::find(const std::string & name) const
{
std::wstring name_wide;
pt::utf8_to_wide(name, name_wide);
return find(name_wide);
}
template<typename StreamType>
Var<StreamType> * Vars<StreamType>::find(const std::wstring & name) const
{
typename VarMap::const_iterator i = var_map.find(name);
if( i != var_map.end() )
{
return i->second;
}
return nullptr;
}
} // namespace
#endif