Beispiel #1
0
/**
 * Assignment operator.  Performs a deep copy of list into this list.
 *
 * @param list  The list to copy
 *
 * @return A reference to this list
 */
template <class T> inline Vector<T>& Vector<T>::operator=(const Vector<T>& list) {
  // clear the list
  clear();

  // increase the capacity to hold the new list
  if (capacity < list.count) {
    capacity = 0;
    delete [] elems;
    elems = new T*[list.capacity];
    if (!elems)
      throw OutOfMemoryException();
    capacity = list.capacity;
  }

  // copy elements
  for (size_t i = 0; i < list.count; i++) {
    elems[i] = new T( *(list.elems[i]) );
    if (!elems[i])
      throw OutOfMemoryException();

    count++;
  }

  return *this;
}
void* MemoryManagerImpl::allocate(XMLSize_t size)
{
    void* memptr;
    try {
        memptr = ::operator new(size);
    }
    catch(...) {
        throw OutOfMemoryException();
    }
    if(memptr==NULL && size!=0)
        throw OutOfMemoryException();
    return memptr;
}
void SerialChannelImpl::handleError(const std::string& name)
{
	std::string errorText;
	DWORD error = GetLastError();

	switch (error)
	{
	case ERROR_FILE_NOT_FOUND:
		throw FileNotFoundException(name, getErrorText(errorText));
	case ERROR_ACCESS_DENIED:
		throw FileAccessDeniedException(name, getErrorText(errorText));
	case ERROR_ALREADY_EXISTS:
	case ERROR_FILE_EXISTS:
		throw FileExistsException(name, getErrorText(errorText));
	case ERROR_FILE_READ_ONLY:
		throw FileReadOnlyException(name, getErrorText(errorText));
	case ERROR_CANNOT_MAKE:
	case ERROR_INVALID_NAME:
	case ERROR_FILENAME_EXCED_RANGE:
		throw CreateFileException(name, getErrorText(errorText));
	case ERROR_BROKEN_PIPE:
	case ERROR_INVALID_USER_BUFFER:
	case ERROR_INSUFFICIENT_BUFFER:
		throw IOException(name, getErrorText(errorText));
	case ERROR_NOT_ENOUGH_MEMORY:
		throw OutOfMemoryException(name, getErrorText(errorText));
	case ERROR_HANDLE_EOF: break;
	default:
		throw FileException(name, getErrorText(errorText));
	}
}
Beispiel #4
0
void SQLite::exec(const String &query)
{
#ifndef HAVE_SQLITE3
	throw UnsupportedFeatureException("SQLite");
#else
	if (!conn) throw NoConnectionException();
	String err;
	double t_start;
	affectedrows=0;
	sqlite3_stmt *stmt=NULL;
	t_start=GetMicrotime();
	int ret=sqlite3_prepare_v2((sqlite3*)conn, (const char*)query, query.size(),&stmt,NULL);
	if (ret!=SQLITE_OK) {
		throw QueryFailedException("sqlite3_prepare_v2 failed: %s",sqlite3_errmsg((sqlite3*)conn));
	}
	if (stmt==NULL) {
		throw OutOfMemoryException();
	}
	ret=sqlite3_step(stmt);
	if (ret!=SQLITE_DONE && ret!=SQLITE_ROW) {
		err.setf("sqlite3_step: %s, Query: %s",sqlite3_errmsg((sqlite3*)conn),(const char*)query);
		sqlite3_finalize(stmt);
		throw QueryFailedException(err);
	}
	ret=sqlite3_finalize(stmt);
	if (ret !=SQLITE_OK) {
		err.setf("sqlite3_finalize: %s, Query: %s",sqlite3_errmsg((sqlite3*)conn),(const char*)query);
		throw QueryFailedException(err);
	}
	affectedrows=sqlite3_changes((sqlite3*)conn);
	updateLastUse();
	logQuery(query,(float)(GetMicrotime()-t_start));
#endif
}
Beispiel #5
0
XERCES_CPP_NAMESPACE_BEGIN

void* MemoryManagerImpl::allocate(size_t size)
{
    void* memptr;
    try {
        memptr = ::operator new(size);
    }
    catch(...) {
        throw OutOfMemoryException();
    }
    if (memptr != NULL) {
        return memptr;
    }
    throw OutOfMemoryException();
}
POCO_LPQUERY_SERVICE_CONFIG WinService::config() const
{
    open();
    int size = 4096;
    DWORD bytesNeeded;
    POCO_LPQUERY_SERVICE_CONFIG pSvcConfig = (POCO_LPQUERY_SERVICE_CONFIG) LocalAlloc(LPTR, size);
    if (!pSvcConfig) throw OutOfMemoryException("cannot allocate service config buffer");
    try
    {
#if defined(POCO_WIN32_UTF8)
        while (!QueryServiceConfigW(_svcHandle, pSvcConfig, size, &bytesNeeded))
#else
        while (!QueryServiceConfigA(_svcHandle, pSvcConfig, size, &bytesNeeded))
#endif
        {
            if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
            {
                LocalFree(pSvcConfig);
                size = bytesNeeded;
                pSvcConfig = (POCO_LPQUERY_SERVICE_CONFIG) LocalAlloc(LPTR, size);
            }
            else throw SystemException("cannot query service configuration", _name);
        }
    }
    catch (...)
    {
        LocalFree(pSvcConfig);
        throw;
    }
    return pSvcConfig;
}
Beispiel #7
0
/**
 * Default constructor that accepts an optional capacity argument.
 *
 * @param capacity The initial capacity of the vector.
 */
template <class T> inline Vector<T>::Vector(int capacity) : elems(0), count(0), capacity(0) {
  elems = new T*[capacity];
  if (!elems)
    throw OutOfMemoryException();

  this->capacity = capacity;
}
Beispiel #8
0
/**
 * Increases the capacity of the vector
 */
template <class T> inline void Vector<T>::grow() {
  // pick a new capacity
  size_t newSize = capacity;
  if (newSize < 16)
    newSize = 16;
  newSize <<= 2;
  if (newSize <= capacity)
    throw IntegerWrapException();

  // allocate the memory
  T** newElems = new T*[newSize];
  if (!newElems)
      throw OutOfMemoryException();

  // copy everything over
  if (elems) {
    memcpy(newElems, elems, count * sizeof(T*));

    // get rid of the old array
    delete [] elems;
  }

  // put it all in place
  elems = newElems;
  capacity = newSize;
}
Beispiel #9
0
/**
* Add data to be sent. (The data will be copied into the send buffers and it is allowed to modify it after this call.)
*/
void CBufferedWriter::Enqueue(const uint8_t* buffer, const uint32_t size)
{
	m_totalLength += size;
	uint32_t remainingSize = size;
	
	//Do we need another buffer ? If yes, flush everything that's possible and allocate a new one.
	while(m_KernelBufRemainingBytes < remainingSize)
	{
		if(0 < m_KernelBufRemainingBytes)
		{
			memcpy(m_KernelBufCursor, buffer, m_KernelBufRemainingBytes);
			buffer += m_KernelBufRemainingBytes;
			remainingSize -= m_KernelBufRemainingBytes;
		}

		bool bSuccess = m_pSendableBufferProvider->GetNextBuffer(m_KernelBufCursor, m_KernelBufRemainingBytes);
		if (false == bSuccess)
		{
			printf("Error: BufferedWriter was unable to obtain more transmission buffers.\n");
			throw OutOfMemoryException();
		}
	}

	//Flush the rest (or everything if the above while loop wasn't entered) into the current buffer
	memcpy(m_KernelBufCursor, buffer, remainingSize);
	m_KernelBufCursor += remainingSize;
	m_KernelBufRemainingBytes -= remainingSize;
}
Beispiel #10
0
aol::Vector<_DataType>::Vector ( const qc::GridStructure &Grid ) : _size ( Grid.getNumberOfNodes() ), _sizeReserved ( _size ), _deleteFlag ( true ), overflowHandling ( aol::CLIP ), overflowMin ( 0 ), overflowMax ( aol::OverflowTrait<DataType>::max ) {
  _pData = static_cast<DataType*> ( aol::MemoryManager::allocateAtLeast ( _sizeReserved, sizeof ( DataType ) ) );
  if ( !_pData )
    throw OutOfMemoryException ( "Vector<DataType,Realtype>::Vector: Could not allocate memory for Vector.", __FILE__, __LINE__ );

  setZero ();
}
Beispiel #11
0
/**
 * Copy constructor.  Performs a deep copy of list.
 *
 * @param list The vector to copy
 */
template <class T> inline Vector<T>::Vector(const Vector<T>& list) : elems(0), count(0), capacity(0) {
  // allocate memory
  elems = new T*[list.capacity];
  if (!elems)
    throw OutOfMemoryException();

  capacity = list.capacity;

  // copy elements
  for (size_t i = 0; i < list.count; i++) {
    elems[i] = new T( *(list.elems[i]) );
    if (!elems[i])
      throw OutOfMemoryException();

    count++;
  }
}
Beispiel #12
0
void* safe_malloc(size_t size) {
  void *ptr = std::malloc(size);

  if (ptr == NULL) {
    throw OutOfMemoryException(size);
  }
  return ptr;
}
Beispiel #13
0
void SocketMessage::setPayload(const String &msg)
{
	clear();
	payload_type=Variant::TYPE_STRING;
	payload_size=msg.size();
	payload=strndup(msg.c_str(),payload_size);
	if (!payload) throw OutOfMemoryException();
}
Beispiel #14
0
void SocketMessage::setPayload(const AssocArray &msg)
{
	clear();
	payload_type=Variant::TYPE_ASSOCARRAY;
	payload_size=msg.binarySize();
	payload=malloc(payload_size);
	if (!payload) throw OutOfMemoryException();
	msg.exportBinary(payload,payload_size,NULL);
}
Beispiel #15
0
/** Constructor.
 * @param name_format format of name to identify the listener,
 * see sprintf for supported tokens
 */
  BlackBoardInterfaceListener::BlackBoardInterfaceListener(const char *name_format, ...)
{
  va_list arg;
  va_start(arg, name_format);
  if (vasprintf(&__name, name_format, arg) == -1) {
    throw OutOfMemoryException("BlackBoardInterfaceListener ctor: vasprintf() failed");
  }
  va_end(arg);
}
Beispiel #16
0
void SocketMessage::setPayload(const ByteArrayPtr &msg)
{
	clear();
	payload_type=Variant::TYPE_BYTEARRAY;
	payload_size=msg.size();
	payload=malloc(payload_size);
	if (!payload) throw OutOfMemoryException();
	memcpy(payload,msg.ptr(),payload_size);
}
Beispiel #17
0
XERCES_CPP_NAMESPACE_BEGIN

void* MemoryManagerArrayImpl::allocate(size_t size)
{
    
    void* memptr;
    try {
        //return ::operator new[](size);
        //return new char[size];
        memptr = new char[size];
    }
    catch(...) {
        throw OutOfMemoryException();
    }
    if (memptr != NULL) {
        return memptr;
    }
    throw OutOfMemoryException();
}
Beispiel #18
0
void* safe_realloc(void *var, size_t size) {
  void *ptr = NULL;

  ptr = std::realloc(var, size);
  if (ptr == NULL && size != 0) {
    throw OutOfMemoryException(size);
  }

  return ptr;
}
Beispiel #19
0
ResultSet *SQLite::query(const String &query)
{
#ifndef HAVE_SQLITE3
	throw UnsupportedFeatureException("SQLite");
#else
	if (!conn) throw NoConnectionException();
	String err;
	double t_start;
	affectedrows=0;
	sqlite3_stmt *stmt=NULL;
	t_start=GetMicrotime();
	int ret=sqlite3_prepare_v2((sqlite3*)conn, (const char*)query, query.size(),&stmt,NULL);
	if (ret!=SQLITE_OK) {
		throw QueryFailedException("sqlite3_prepare_v2 failed: %s",sqlite3_errmsg((sqlite3*)conn));
	}
	if (stmt==NULL) {
		throw OutOfMemoryException();
	}
	ret=sqlite3_step(stmt);
	if (ret!=SQLITE_DONE && ret!=SQLITE_ROW) {
		err.setf("sqlite3_step: %s, Query: %s",sqlite3_errmsg((sqlite3*)conn),(const char*)query);
		sqlite3_finalize(stmt);
		throw QueryFailedException(err);
	}
	affectedrows=sqlite3_changes((sqlite3*)conn);
	updateLastUse();
	logQuery(query,(float)(GetMicrotime()-t_start));

	SQLiteResult *pr=new SQLiteResult;
	if (!pr) {
		sqlite3_finalize(stmt);
		throw OutOfMemoryException();
	}
	pr->stmt=stmt;
	pr->last_res=ret;
	pr->sqlite_class=this;
	pr->conn=(sqlite3 *)conn;
	pr->affectedrows=affectedrows;
	pr->num_fields=sqlite3_column_count(stmt);
	return pr;
#endif
}
Beispiel #20
0
/** Execute file on a specific Lua state.
 * @param L Lua state to execute the file in.
 * @param filename filet to load and excute.
 */
void
LuaContext::do_file(lua_State *L, const char *filename)
{
  // Load initialization code
  int err = 0;
  std::string errmsg;
  if ( (err = luaL_loadfile(L, filename)) != 0) {
    errmsg = lua_tostring(L, -1);
    lua_pop(L, 1);
    switch (err) {
    case LUA_ERRSYNTAX:
      throw SyntaxErrorException("Lua syntax error in file %s: %s", filename, errmsg.c_str());

    case LUA_ERRMEM:
      throw OutOfMemoryException("Could not load Lua file %s", filename);

    case LUA_ERRFILE:
      throw CouldNotOpenFileException(filename, errmsg.c_str());
    }
  }

  int errfunc = __enable_tracebacks ? 1 : 0;
  if ( (err = lua_pcall(L, 0, LUA_MULTRET, errfunc)) != 0 ) {
    // There was an error while executing the initialization file
    errmsg = lua_tostring(L, -1);
    lua_pop(L, 1);
    switch (err) {
    case LUA_ERRRUN:
      throw LuaRuntimeException("do_file", errmsg.c_str());

    case LUA_ERRMEM:
      throw OutOfMemoryException("Could not execute Lua file %s", filename);

    case LUA_ERRERR:
      throw LuaErrorException("do_file", errmsg.c_str());

    default:
      throw LuaErrorException("do_file/unknown error", errmsg.c_str());
    }
  }

}
const char *
RRDGraphGPrint::to_string() const
{
  if (! __string) {
    if (asprintf(&__string, "GPRINT:%s:%s:%s", __def_name,
		 RRDArchive::cf_to_string(__cf), __format) == -1) {
      throw OutOfMemoryException("Failed to create RRD graph GPRINT string");
    }
  }

  return __string;
}
Beispiel #22
0
/** Set thread instance in thread-specific data (TSD).
 * Use thread-specific data to store a reference to the Thread instance in the
 * pthread struct. Used by current_thread().
 * @param t thread to set specific data on
 */
void
Thread::set_tsd_thread_instance(Thread *t)
{
  int err = 0;
  if ( (err = pthread_setspecific(THREAD_KEY, t)) != 0 ) {
    if ( ENOMEM == err ) {
      throw OutOfMemoryException("Could not set specific data (reference to thread)");
    } else {
      throw Exception("Could not set specific data (reference to thread), unknown reason");
    }
  }
}
/** Create string representation.
 * @return string representation suitable for rrd_graph_v().
 */
const char *
RRDGraphDataDefinition::to_string() const
{
  if (! __string) {
    if (__rpn_expression) {
      if (asprintf(&__string, "CDEF:%s=%s", __name, __rpn_expression) == -1) {
	throw OutOfMemoryException("Failed to create RRA string");
      }
    } else {
      size_t ds_index = __rrd_def->find_ds_index(__ds_name);

      if (asprintf(&__string, "DEF:%s=%s:%s:%s", __name, __rrd_def->get_filename(),
		   __rrd_def->get_ds(ds_index).get_name(),
		   RRDArchive::cf_to_string(__cf)) == -1) {
	throw OutOfMemoryException("Failed to create RRA string");
      }
    }
  }

  return __string;
}
/** Convert int value to a string.
 * @param i value to convert
 * @return string representation of value.
 */
std::string
StringConversions::to_string(const int i)
{
  char *tmp;
  std::string rv;
  if (asprintf(&tmp, "%i", i) == -1) {
    throw OutOfMemoryException("StringConversions::tostring(const int): asprintf() failed");
  }
  rv = tmp;
  free(tmp);
  return rv;
}
const char *
RRDGraphArea::to_string() const
{
  if (! __string) {
    if (asprintf(&__string, "AREA:%s#%s:%s%s", __def_name, __color, __legend,
		 __stacked ? ":STACK" : "") == -1) {
      throw OutOfMemoryException("Failed to create RRD graph AREA string");
    }
  }

  return __string;
}
Beispiel #26
0
/**
 * Add a copy of item to the end of the list.
 *
 * @param item The item to add.
 */
template <class T> inline void Vector<T>::append(const T& item) {
  // ensure capacity
  if (count >= capacity)
    grow();

  // create the item we'll hold on to
  T* t = new T(item);
  if (!t)
    throw OutOfMemoryException();

  // put it in the list
  elems[count++] = t;
}
Beispiel #27
0
/** Set name of thread.
 * If you want a more descriptive thread name you can do so by calling this method
 * in your thread's constructor, and only in the constructor.
 * Use parameters similar to printf().
 * @param format format string
 */
void
Thread::set_name(const char *format, ...)
{
  va_list va;
  va_start(va, format);
  char *old_name = __name;
  if (vasprintf(&__name, format, va) == -1) {
    __name = old_name;
    throw OutOfMemoryException("Could not set new thread name for '%s'", __name);
  } else {
    free(old_name);
  }
  va_end(va);
}
Beispiel #28
0
 void ESolver::CheckResourceLimits()
 {
     if(ResourceLimitManager::CheckTimeOut()) {
         EndSolve();
         SolveEndTime = TimeValue::GetTimeValue();
         SolveEndMemStats = MemStats::GetMemStats();
         throw OutOfTimeException("Query time limit exceeded");
     } else if(ResourceLimitManager::CheckMemOut()) {
         EndSolve();
         SolveEndTime = TimeValue::GetTimeValue();
         SolveEndMemStats = MemStats::GetMemStats();
         throw OutOfMemoryException("Out of memory");
     }
 }
/** Get string reprensetation.
 * @return string representation suitable to be bassed to rrd_create().
 */
const char *
RRDDataSource::to_string() const
{
  if (! __string) {
    if (__type == COMPUTE) {
      if (asprintf(&__string, "DS:%s:COMPUTE:%s", __name, __rpn_expression) == -1) {
	throw OutOfMemoryException("Failed to create DS string for %s", __name);
      }
    } else {
      const char *type_string;
      switch (__type) {
      case COUNTER:  type_string = "COUNTER";  break;
      case DERIVE:   type_string = "DERIVE";   break;
      case ABSOLUTE: type_string = "ABSOLUTE"; break;
      default:       type_string = "GAUGE";    break;
      }
      char min_s[32];
      char max_s[32];
      if (__min == UNKNOWN) {
	strcpy(min_s, "U");
      } else {
	snprintf(min_s, 32, "%f", __min);
      }
      if (__max == UNKNOWN) {
	strcpy(max_s, "U");
      } else {
	snprintf(max_s, 32, "%f", __max);
      }
      if (asprintf(&__string, "DS:%s:%s:%u:%s:%s", __name, type_string,
		   __heartbeat, min_s, max_s) == -1) {
	throw OutOfMemoryException("Failed to create DS string for %s", __name);
      }
    }
  }

  return __string;
}
Beispiel #30
0
/** Set name of thread.
 * Use parameters similar to printf().
 * @param format format string
 */
void
ThreadList::set_name(const char *format, ...)
{
  va_list va;
  va_start(va, format);
  
  char *tmpname;
  if (vasprintf(&tmpname, format, va) != -1) {
    free(__name);
    __name = tmpname;
  } else {
    throw OutOfMemoryException("ThreadList::set_name(): vasprintf() failed");
  }
  va_end(va);
}