// // //Add cell to the list
  void addCell(initializer_list<int_8 > l) {    
    if (l.size() == 2) {
      listCell.emplace_back( shared_ptr<Cell > (new Line(l)) ); 
 //     //listCell.emplace_back(shared_ptr<Cell > (new Line(tmp)) );
    } else if (l.size() == 3) {
  //     //listCell.emplace_back(shared_ptr<Cell > (new Tri(tmp)) ); 
    } else if (l.size() == 4) {
      listCell.emplace_back( shared_ptr<Cell > (new Quad(l)) ); 
    } else if (l.size() == 8) {
       //listCell.emplace_back( shared_ptr<Cell > (new Hexa(tmp)) ); 
    } else {
      cout << "Cell type not understood!"<<endl; 
      exit(1); 
    }
    nCellSize += l.size() + 1;
    auto c = *(listCell.rbegin()); 

    c->id = listCell.size()-1;
    c->grid = this; 
    c->assignCelltoNode();
    for (auto v: listVar) {
      if (v->loc == 0) {
	v->data.push_back(0); 
	v->data.uncompress();
      }
    }
    c->masterx.resize(levelHighBound[0]+1, false); 
    c->mastery.resize(levelHighBound[1]+1, false); 
    c->masterz.resize(levelHighBound[2]+1, false); 
  }

int makeSum(initializer_list<int> lst)
{
    int total = 0;
    for(auto iter = lst.begin(); iter!=lst.end(); ++iter)
	total += (*iter);
    return total;
}

	PointSequence(initializer_list<double> args)
	{
		if (args.size() % 2 != 0)
			throw invalid_argument("initializer_list should contain even number of elements.");
		for (auto iter = args.begin(); iter != args.end(); ++iter)
			mVecPoints.push_back(*iter);
	}

	Animation(int x, int y, initializer_list<char> chars, int speed = 5) : speed(speed), frame(1), counter(0)
	{
		Collision = true;
		Pos.Set(x, y);
		for(auto i = chars.begin(); i != chars.end(); ++i) frames.push_back(*i);
		Visual = frames[0];
	}

SparseVector::SparseVector(long size, long default_val, initializer_list<pair<long,long> > list)
{
    if (size < 0) {
        throw range_error("SparseVector size cannot be negative.");
    } else {
        fixed_size_ = size;
        unset_val_ = default_val;
    }      
    
    long count = 0;
    for (auto i = list.begin(); i != list.end(); i++) {
        
        if (i->first < (fixed_size_ - 1) && i->first >= 0) {
                      
            if (i->second != unset_val_) {
                data_[i->first] = data_[i->second];
            }
            
        } else {
            throw range_error("Cannot set value at an index greater than the size - 1 or less than 0.");
        }
        
        ++count;
    }
}

EvenSequenceStr::EvenSequenceStr(initializer_list<string> args)
{
  if (args.size() % 2 != 0)
    throw invalid_argument(" initializer_list should contain even number of elements!");
  sSequence.reserve(args.size());
  //for (auto value : args)  sSequence.push_back(value);
  sSequence.insert(cend(sSequence), cbegin(args), cend(args)); // alternate to the above for loop
}

		Function(const char* name, const char* returns, initializer_list<char*> takes, const char* description) : Type(name) {
			this->takes = new char*[takes.size() + 1];
			int index = 0;
			for (auto i : takes) { this->takes[index++] = i; }
			this->takes[takes.size()] = 0;
			this->returns = returns;
			this->description = description;
		}

 Vector(initializer_list<T> list) : size{list.size()}
 {
     cout << "initializer list constructor" << endl;
     int i = 0;
     a.reset(new T[size]);
     for (auto iter = list.begin(); iter != list.end(); ++iter, ++i)
         a.get()[i] = *iter;
 }

StrVec::StrVec(initializer_list<string> il)
{
	reallocate(il.size());
	auto p = begin_iter;
	for (auto beg = il.begin(); beg != il.end(); ++beg)
		alloc.construct(p++, *beg);
	end_iter = p;
}

int cal_sum(initializer_list<int> &list)
{
	int sum = 0;
	for (auto i = list.begin(); i != list.end(); ++i) {
		sum += *i;
	}
	return sum;
}

int summation(initializer_list<int> val)
{
	int ret = 0;
	for (auto beg = val.begin(); beg != val.end(); ++beg)
	{
		ret += *beg;
	}
	return ret;
} 

Image::Image(int _rows,int _cols,initializer_list<float> _data):rows(_rows),cols(_cols){
	this->allocate();

	#if IMAGE_SAFE == 1
		assert(_data.size() == rows*cols);
	#endif

	std::copy(_data.begin(), _data.end(), data.get());
}

Vector::Vector(initializer_list<double> args)
{
	auto it = args.begin();
	element_count = args.size();
	memory_size = element_count * 2;
	vector = (double*)malloc(memory_size * sizeof(double));
	int i;
	for (it, i = 0; it != args.end(); it++, i++)
		vector[i] = *it;
}

	//local->world
	Matrix44 TransformHelper::CreateWorld(initializer_list<Matrix44> matrixOrder)
	{	//스케일, 자전, 이동, 공전, 부모 순으로 넣으면 된다.
		Matrix44 matWorld;
		for( auto iter = matrixOrder.begin(); iter != matrixOrder.end(); ++iter )
		{
			matWorld = (*iter) * matWorld;
		}

		return matWorld;
	}

Army::Army(Player* owner, initializer_list<Unit*> units) : owner(owner), isPatrol(false), position(Position(-1, -1, ARCANUS)), route(nullptr)
{
    owner->add(this);

    for (auto u : units)
        add(u);

    if (units.begin() != units.end())
        updateMovementType();
}

Vector<T>::Vector(const initializer_list<T>& l) {
    static_assert(is_move_assignable<T>::value, "Type is not move assignable.");
    static_assert(is_move_constructible<T>::value, "Type is not move constructible."); // Can be constructed fr rvalue
    vectorsize = l.size();
    heap_size = l.size();
    array = new T[vectorsize];
    for (int i = 0; i < vectorsize; ++i) {
        array[i] = l.begin()[i];
    }
}

void subscriptCheck(initializer_list<int> lst)
{
	cout<<"initializer_list subscript check\n";

	// for(int i = 0; i < lst.size(); ++i)
	// 	cout<<lst[i]<<'\n';   // error

	const int* p = lst.begin();
	for(int i = 0; i <  lst.size(); ++i)
		cout<<p[i]<<'\n';
}

RunTimeContainer::RunTimeContainer(initializer_list<RunTime> initializer) {
	if (ZoneHandler::getZoneCount() != initializer.size()) {
		throw logic_error("ZoneHandler::getZoneCount() != initializer.size()");
	}

	container.reserve(ZoneHandler::getZoneCount());
	for (size_t i = 0; i < ZoneHandler::getZoneCount(); ++i) {
		shared_ptr<RunTime> runTime(new RunTime(*next(initializer.begin(), i)));
		container.push_back(make_pair(i, runTime));
	}
}

    template<typename T> Polynomial(initializer_list<T> list){
        coeffs.resize(list.size());

        int i=list.size()-1;
        for(T t:list){
            coeffs[i]=t;
            i--;
        }

        reduce();
    }

StateTreeNode::StateTreeNode(
	initializer_list<double> center,
	double halfSize,
	int maxDepth
) :
	numSpacePartitions(pow(2, center.size()))
{
	for(unsigned int n = 0; n < center.size(); n++)
		this->center.push_back(*(center.begin() + n));

	this->halfSize = halfSize;
	this->maxDepth = maxDepth;
}