github.com/platonnetwork/platon-go@v0.7.6/cases/tool/win/bls_win/include/mcl/array.hpp (about)

     1  #pragma once
     2  /**
     3  	@file
     4  	@brief tiny vector class
     5  	@author MITSUNARI Shigeo(@herumi)
     6  	@license modified new BSD license
     7  	http://opensource.org/licenses/BSD-3-Clause
     8  */
     9  #include <stdlib.h>
    10  #include <stddef.h>
    11  #ifndef CYBOZU_DONT_USE_EXCEPTION
    12  #include <new>
    13  #endif
    14  
    15  namespace mcl {
    16  
    17  template<class T>
    18  class Array {
    19  	T *p_;
    20  	size_t n_;
    21  	template<class U>
    22  	void swap_(U& x, U& y) const
    23  	{
    24  		U t;
    25  		t = x;
    26  		x = y;
    27  		y = t;
    28  	}
    29  public:
    30  	Array() : p_(0), n_(0) {}
    31  	~Array()
    32  	{
    33  		free(p_);
    34  	}
    35  #ifndef CYBOZU_DONT_USE_EXCEPTION
    36  	Array(const Array& rhs)
    37  		: p_(0)
    38  		, n_(0)
    39  	{
    40  		if (rhs.n_ == 0) return;
    41  		p_ = (T*)malloc(sizeof(T) * rhs.n_);
    42  		if (p_ == 0) throw std::bad_alloc();
    43  		n_ = rhs.n_;
    44  		for (size_t i = 0; i < n_; i++) {
    45  			p_[i] = rhs.p_[i];
    46  		}
    47  	}
    48  	Array& operator=(const Array& rhs)
    49  	{
    50  		Array tmp(rhs);
    51  		tmp.swap(*this);
    52  		return *this;
    53  	}
    54  #endif
    55  	bool resize(size_t n)
    56  	{
    57  		if (n <= n_) {
    58  			n_ = n;
    59  			if (n == 0) {
    60  				free(p_);
    61  				p_ = 0;
    62  			}
    63  			return true;
    64  		}
    65  		T *q = (T*)malloc(sizeof(T) * n);
    66  		if (q == 0) return false;
    67  		for (size_t i = 0; i < n_; i++) {
    68  			q[i] = p_[i];
    69  		}
    70  		free(p_);
    71  		p_ = q;
    72  		n_ = n;
    73  		return true;
    74  	}
    75  	bool copy(const Array<T>& rhs)
    76  	{
    77  		if (this == &rhs) return true;
    78  		if (n_ < rhs.n_) {
    79  			clear();
    80  			if (!resize(rhs.n_)) return false;
    81  		}
    82  		for (size_t i = 0; i < rhs.n_; i++) {
    83  			p_[i] = rhs.p_[i];
    84  		}
    85  		n_ = rhs.n_;
    86  		return true;
    87  	}
    88  	void clear()
    89  	{
    90  		free(p_);
    91  		p_ = 0;
    92  		n_ = 0;
    93  	}
    94  	size_t size() const { return n_; }
    95  	void swap(Array<T>& rhs)
    96  	{
    97  		swap_(p_, rhs.p_);
    98  		swap_(n_, rhs.n_);
    99  	}
   100  	T& operator[](size_t n) { return p_[n]; }
   101  	const T& operator[](size_t n) const { return p_[n]; }
   102  	T* data() { return p_; }
   103  	const T* data() const { return p_; }
   104  };
   105  
   106  template<class T, size_t maxSize>
   107  class FixedArray {
   108  	T p_[maxSize];
   109  	size_t n_;
   110  	FixedArray(const FixedArray&);
   111  	void operator=(const FixedArray&);
   112  	template<class U>
   113  	void swap_(U& x, U& y) const
   114  	{
   115  		U t;
   116  		t = x;
   117  		x = y;
   118  		y = t;
   119  	}
   120  public:
   121  	FixedArray() : n_(0) {}
   122  	bool resize(size_t n)
   123  	{
   124  		if (n > maxSize) return false;
   125  		n_ = n;
   126  		return true;
   127  	}
   128  	bool copy(const FixedArray<T, maxSize>& rhs)
   129  	{
   130  		if (this == &rhs) return true;
   131  		for (size_t i = 0; i < rhs.n_; i++) {
   132  			p_[i] = rhs.p_[i];
   133  		}
   134  		n_ = rhs.n_;
   135  		return true;
   136  	}
   137  	void clear()
   138  	{
   139  		n_ = 0;
   140  	}
   141  	size_t size() const { return n_; }
   142  	void swap(FixedArray<T, maxSize>& rhs)
   143  	{
   144  		T *minP = p_;
   145  		size_t minN = n_;
   146  		T *maxP = rhs.p_;
   147  		size_t maxN = rhs.n_;
   148  		if (minP > maxP) {
   149  			swap_(minP, maxP);
   150  			swap_(minN, maxN);
   151  		}
   152  		for (size_t i = 0; i < minN; i++) {
   153  			swap_(minP[i], maxP[i]);
   154  		}
   155  		for (size_t i = minN; i < maxN; i++) {
   156  			minP[i] = maxP[i];
   157  		}
   158  		swap_(n_, rhs.n_);
   159  	}
   160  	T& operator[](size_t n) { return p_[n]; }
   161  	const T& operator[](size_t n) const { return p_[n]; }
   162  	T* data() { return p_; }
   163  	const T* data() const { return p_; }
   164  };
   165  
   166  } // mcl
   167