GroupElement * CryptoPpDlogZpSafePrime::encodeByteArrayToGroupElement(const vector<unsigned char> & binaryString) {
//Any string of length up to k has numeric value that is less than (p-1)/2 - 1.
//If longer than k then throw exception.
int bs_size = binaryString.size();
if (bs_size > k) {
throw length_error("The binary array to encode is too long.");
}
//Pad the binaryString with a x01 byte in the most significant byte to ensure that the
//encoding and decoding always work with positive numbers.
list<unsigned char> newString(binaryString.begin(), binaryString.end());
newString.push_front(1);
byte *bstr = new byte[bs_size + 1];
for (auto it = newString.begin(); it != newString.end(); ++it) {
int index = std::distance(newString.begin(), it);
bstr[index] = *it;
}
biginteger s = cryptoppint_to_biginteger(CryptoPP::Integer(bstr, bs_size + 1));
//Denote the string of length k by s.
//Set the group element to be y=(s+1)^2 (this ensures that the result is not 0 and is a square)
biginteger y = boost::multiprecision::powm((s + 1), 2, ((ZpGroupParams *)groupParams)->getP());
//There is no need to check membership since the "element" was generated so that it is always an element.
ZpSafePrimeElementCryptoPp * element = new ZpSafePrimeElementCryptoPp(y, ((ZpGroupParams * )groupParams)->getP(), false);
delete(bstr);
return element;
}
string toUtf8String(const wstring& wide) {
if (wide.size() > boost::integer_traits<int>::const_max)
throw length_error(
"Wide string cannot be more than INT_MAX characters long.");
if (wide.size() == 0)
return "";
// Calculate necessary buffer size
int len = ::WideCharToMultiByte(
CP_UTF8, 0, wide.c_str(), static_cast<int>(wide.size()),
NULL, 0, NULL, NULL);
// Perform actual conversion
if (len > 0) {
vector<char> buffer(len);
len = ::WideCharToMultiByte(
CP_UTF8, 0, wide.c_str(), static_cast<int>(wide.size()),
&buffer[0], static_cast<int>(buffer.size()), NULL, NULL);
if (len > 0) {
assert(len == static_cast<int>(buffer.size()));
return string(&buffer[0], buffer.size());
}
}
throw boost::system::system_error(
::GetLastError(), boost::system::system_category());
}
string Base64::Encode(const string &bindata)
{
if (bindata.size() > (numeric_limits<string::size_type>::max() / 4u) * 3u) {
throw length_error("Converting too large a string to base64.");
}
const size_t binlen = bindata.size();
// Use = signs so the end is properly padded.
string retval((((binlen + 2) / 3) * 4), '=');
//string retval(ceil(((binlen) / 3.0) * 4.0), '='); //this doesn't seem
//to be complian with the standard and it fails to decode with
//python decode function
size_t outpos = 0;
int bits_collected = 0;
unsigned int accumulator = 0;
const string::const_iterator binend = bindata.end();
for (string::const_iterator i = bindata.begin(); i != binend; ++i) {
accumulator = (accumulator << 8) | (*i & 0xffu);
bits_collected += 8;
while (bits_collected >= 6) {
bits_collected -= 6;
retval[outpos++] = b64_table[(accumulator >> bits_collected) & 0x3fu];
}
}
if (bits_collected > 0) { // Any trailing bits that are missing.
assert(bits_collected < 6);
accumulator <<= 6 - bits_collected;
retval[outpos++] = b64_table[accumulator & 0x3fu];
}
//assert(outpos >= (retval.size() - 2));
assert(outpos <= retval.size());
return retval;
}
void wstring::resize(size_t n, wchar_t c) {
if (n > max_size())
throw length_error("n > max_size()");
if (n > length())
append(n - length(), c);
else
erase(n);
}
int pop() {
if (maxHeap_.empty())
throw length_error("stack empty");
TimestampValue tmp = maxHeap_.top();
maxHeap_.pop();
return tmp.value;
}
/**
** WORKS
**/
set<string> WordSearch::files_with_most_frequent_words() throw(length_error) {
if (leastFrequent.rbegin() == leastFrequent.rend()) // Err if empty
throw length_error ("length error");
set<string> files;
for (auto iter = leastFrequent.rbegin()->second.begin(); iter!=leastFrequent.rbegin()->second.end(); iter++){
files.insert(wordFileMap[*iter].begin(),wordFileMap[*iter].end());
}
return files;
}
T dequeue()
{
if(_count)
{
T ret = _data[head];
_count--;
_head = (_head+1)%_data.size();
return ret;
}
else throw length_error(“Queue is Empty”);
}
RealVector RealVector::operator /(const RealVector& rhs) const {
RealVector ret(*this);
int i;
if (rhs.n != n)
throw length_error("Lengths of vectors are unequal");
for (i = 0; i < n; i++) {
ret.entries[i] /= rhs.entries[i];
}
return ret;
}
void lowerMatrix<T>::setsize(const int size)
{
if (size < 0)
{
throw length_error("setsize param");
}
m_dimentions = size;
m_data.setsize(size);
for (int i=0; i < size; i++)
{
m_data[i].setsize(i+1);
}
return;
}
string str::wordWrap(string in, unsigned cols) {
unsigned i = cols;
while (i < in.size()) {
for (; i > 0; i--) {
if (isspace(int((in.at(i))))) {
in.replace(i, 1, "\n");
break;
}
}
if (i == 0) {
throw length_error("length of word exceeds cols");
}
i += cols;
}
return in;
}
VideoFrame::VideoFrame(const uint8_t *data, size_t size, PixelFormat pixelFormat, int width, int height, int align)
: VideoFrame(pixelFormat, width, height, align)
{
size_t calcSize = av_image_get_buffer_size(pixelFormat, width, height, align);
if (calcSize != size)
throw length_error("Data size and required buffer for this format/width/height/align not equal");
uint8_t *buf[4];
int linesize[4];
av_image_fill_arrays(buf, linesize, data, pixelFormat, width, height, align);
// copy data
for (size_t i = 0; i < 4 && buf[i]; ++i) {
std::copy(buf[i], buf[i]+linesize[i], m_raw->data[i]);
}
}
AudioSamples::AudioSamples(const uint8_t *data, size_t size, SampleFormat sampleFormat, int samplesCount, uint64_t channelLayout, int sampleRate, int align)
: AudioSamples(sampleFormat, samplesCount, channelLayout, sampleRate, align)
{
const auto channels = av_get_channel_layout_nb_channels(channelLayout);
auto calcSize = sampleFormat.requiredBufferSize(channels, samplesCount, align);
if (calcSize > size)
throw length_error("Data size and required buffer for this format/nb_samples/nb_channels/align not equal");
uint8_t *buf[AV_NUM_DATA_POINTERS];
int linesize[AV_NUM_DATA_POINTERS];
SampleFormat::fillArrays(buf, linesize, data, channels, samplesCount, sampleFormat, align);
// copy data
for (size_t i = 0; i < size_t(channels) && i < size_t(AV_NUM_DATA_POINTERS); ++i) {
std::copy(buf[i], buf[i]+linesize[i], m_raw->data[i]);
}
}
wstring& wstring::replace(size_t pos, size_t n1, const wchar_t* s, size_t n2) {
const size_t len = length();
if (pos > len)
throw out_of_range("pos > len");
if (n1 > len - pos)
n1 = len - pos;
if (len - n1 > max_size() - n2)
throw length_error("len - n1 > max_size() - n2");
size_t newlen = len - n1 + n2;
if (check_realloc(newlen)) {
Rep *p = Rep::create(newlen);
p->copy(0, data(), pos);
p->copy(pos + n2, data() + pos + n1, len -(pos + n1));
p->copy(pos, s, n2);
repup(p);
}
else {
rep()->move(pos + n2, data() + pos + n1, len -(pos + n1));
rep()->copy(pos, s, n2);
}
rep()->len = newlen;
return *this;
}
T max(){
if(empty() == false)
return _s.top().second;
else
throw length_error("Empty Stack");
}
_UCXXEXPORT void __throw_length_error(const char * message){
if(message == 0){
throw length_error();
}
throw length_error(message);
}
void __throw_length_error(const char* s) { throw length_error(s); }
T pop(){
if(empty() == true)
throw length_error("Empty Stack");
else
return _s.pop();
}
/**
** WORKS
**/
pair<unsigned int,set<string>> WordSearch::most_frequent_words() const throw (length_error) {
if (leastFrequent.rbegin() == leastFrequent.rend()) // Err if empty
throw length_error ("length error");
return make_pair(leastFrequent.rbegin()->first,leastFrequent.rbegin()->second);
// Otherwise return the end of the map (map is already sorted least to greatest)
}
int top() const {
if (maxHeap_.empty())
throw length_error("stack empty");
return maxHeap_.top().value;
}
