PassRefPtr<StringImpl> StringImpl::upper()
{
bool error;
int32_t length = Unicode::toUpper(0, 0, m_data, m_length, &error);
StringBuffer data(length);
Unicode::toUpper(data.characters(), length, m_data, m_length, &error);
if (error)
return this;
return adopt(data);
}
void FileMonitor::scan()
{
IBRCOMMON_LOGGER_DEBUG_TAG("FileMonitor", 5) << "scan for file changes" << IBRCOMMON_LOGGER_ENDL;
std::set<ibrcommon::File> watch_set;
for (watch_set::iterator iter = _watchset.begin(); iter != _watchset.end(); ++iter)
{
const ibrcommon::File &path = (*iter);
std::list<ibrcommon::File> files;
if (path.getFiles(files) == 0)
{
for (std::list<ibrcommon::File>::iterator iter = files.begin(); iter != files.end(); ++iter)
{
watch_set.insert(*iter);
}
}
else
{
IBRCOMMON_LOGGER_TAG("FileMonitor", error) << "scan of " << path.getPath() << " failed" << IBRCOMMON_LOGGER_ENDL;
}
}
// check for new directories
for (std::set<ibrcommon::File>::iterator iter = watch_set.begin(); iter != watch_set.end(); ++iter)
{
const ibrcommon::File &path = (*iter);
if (path.isDirectory() && !path.isSystem())
{
if (!isActive(path)) {
adopt(path);
}
}
}
// look for gone directories
for (std::map<ibrcommon::File, dtn::core::Node>::iterator iter = _active_paths.begin(); iter != _active_paths.end();)
{
const ibrcommon::File &path = (*iter).first;
const dtn::core::Node &node = (*iter).second;
if (watch_set.find(path) == watch_set.end())
{
dtn::core::BundleCore::getInstance().getConnectionManager().remove(node);
IBRCOMMON_LOGGER_DEBUG_TAG("FileMonitor", 5) << "Node on drive gone: " << node.getEID().getString() << IBRCOMMON_LOGGER_ENDL;
_active_paths.erase(iter++);
}
else
{
++iter;
}
}
}
// This is a hot function because it's used when parsing HTML.
PassRefPtr<StringImpl> StringImpl::createStrippingNullCharactersSlowCase(const UChar* characters, unsigned length)
{
StringBuffer strippedCopy(length);
unsigned strippedLength = 0;
for (unsigned i = 0; i < length; i++) {
if (int c = characters[i])
strippedCopy[strippedLength++] = c;
}
ASSERT(strippedLength < length); // Only take the slow case when stripping.
strippedCopy.shrink(strippedLength);
return adopt(strippedCopy);
}
RTree::Trunk::Trunk( RTree::Trunk *parent ) {
// initialize all of the variables
type = node_trunk_t;
num_children = 0;
adopt( parent );
for( int i = 0; i < max_children; ++i ) {
children[i] = NULL;
}
} /* ----- end of method RTree::Trunk::Trunk (constructor) ----- */
bool ObjectProxy::build_child(const std::string &name, const Value &attrs, Value *error, ObjectHandle *handle) {
if (!root_proxy_ || !root_proxy_->proxy_factory()) {
std::cerr << "Cannot build child /" << name << " : no RootProxy or no ProxyFactory !\n";
return false;
}
Object *obj = adopt(root_proxy_->proxy_factory()->build_object_proxy(this, name, attrs));
if (obj) {
handle->hold(obj);
return true;
} else {
return false;
}
}
void Delay::RegisterWithLua ( LuaSystem::LuaVirtualMachine* pVM )
///////////////////////////////////////////////////////////////////////
{
module(*pVM)
[
class_<Delay,Animatable>("Delay")
.def(constructor<double>())
.def("Run", &Delay::Run)
.def("Stop", &Animatable::Stop)
.def("Add", &Animatable::Add, adopt(_2))
];
}
PassRefPtr<StringImpl> StringImpl::replace(unsigned position, unsigned lengthToReplace, StringImpl* str)
{
position = min(position, length());
lengthToReplace = min(lengthToReplace, length() - position);
unsigned lengthToInsert = str ? str->length() : 0;
if (!lengthToReplace && !lengthToInsert)
return this;
StringBuffer buffer(length() - lengthToReplace + lengthToInsert);
memcpy(buffer.characters(), characters(), position * sizeof(UChar));
if (str)
memcpy(buffer.characters() + position, str->characters(), lengthToInsert * sizeof(UChar));
memcpy(buffer.characters() + position + lengthToInsert, characters() + position + lengthToReplace,
(length() - position - lengthToReplace) * sizeof(UChar));
return adopt(buffer);
}
PassRefPtr<StringImpl> StringImpl::replace(StringImpl* pattern, StringImpl* replacement)
{
if (!pattern || !replacement)
return this;
int patternLength = pattern->length();
if (!patternLength)
return this;
int repStrLength = replacement->length();
int srcSegmentStart = 0;
int matchCount = 0;
// Count the matches
while ((srcSegmentStart = find(pattern, srcSegmentStart)) >= 0) {
++matchCount;
srcSegmentStart += patternLength;
}
// If we have 0 matches, we don't have to do any more work
if (!matchCount)
return this;
StringBuffer data(m_length + matchCount * (repStrLength - patternLength));
// Construct the new data
int srcSegmentEnd;
int srcSegmentLength;
srcSegmentStart = 0;
int dstOffset = 0;
while ((srcSegmentEnd = find(pattern, srcSegmentStart)) >= 0) {
srcSegmentLength = srcSegmentEnd - srcSegmentStart;
memcpy(data.characters() + dstOffset, m_data + srcSegmentStart, srcSegmentLength * sizeof(UChar));
dstOffset += srcSegmentLength;
memcpy(data.characters() + dstOffset, replacement->m_data, repStrLength * sizeof(UChar));
dstOffset += repStrLength;
srcSegmentStart = srcSegmentEnd + patternLength;
}
srcSegmentLength = m_length - srcSegmentStart;
memcpy(data.characters() + dstOffset, m_data + srcSegmentStart, srcSegmentLength * sizeof(UChar));
ASSERT(dstOffset + srcSegmentLength == static_cast<int>(data.length()));
return adopt(data);
}
EGLPlatformContext::EGLPlatformContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share, EGLDisplay display,
EGLConfig *config, const QVariant &nativeHandle, Flags flags)
: m_eglDisplay(display)
, m_swapInterval(-1)
, m_swapIntervalEnvChecked(false)
, m_swapIntervalFromEnv(-1)
, m_flags(flags)
{
if (nativeHandle.isNull()) {
m_eglConfig = config ? *config : EglUtils::configFromGLFormat(display, format);
m_ownsContext = true;
init(format, share);
} else {
m_ownsContext = false;
adopt(nativeHandle, share);
}
}
PassRefPtr<StringImpl> StringImpl::replace(UChar oldC, UChar newC)
{
if (oldC == newC)
return this;
unsigned i;
for (i = 0; i != m_length; ++i)
if (m_data[i] == oldC)
break;
if (i == m_length)
return this;
StringBuffer data(m_length);
for (i = 0; i != m_length; ++i) {
UChar ch = m_data[i];
if (ch == oldC)
ch = newC;
data[i] = ch;
}
return adopt(data);
}
static std::shared_ptr<SkSurface> create_raster_surface(int w, int h) {
std::cout << "Using raster surface" << std::endl;
return adopt(SkSurface::MakeRasterN32Premul(w, h).release());
}
static int test(hwloc_topology_t orig, const char *callname) {
unsigned long forced_addr;
unsigned long fileoffset;
size_t shmem_length;
int synthetic_with_distances = (hwloc_obj_get_info_by_name(hwloc_get_root_obj(orig), "SyntheticDescription") != NULL);
char tmpname[] = "/tmp/hwloc_test_shmem.XXXXXX";
char cmd[512];
struct stat st;
int fd, err;
int ret = EXIT_SKIP;
printf("opening temporary file\n");
fd = mkstemp(tmpname);
if (fd < 0) {
perror("mkstemp");
goto out;
}
printf("opened %s\n", tmpname);
printf("exporting XML\n");
err = hwloc_topology_export_xml(orig, tmpname, 0);
assert(!err);
err = stat(tmpname, &st);
assert(!err);
printf("exported %lu bytes\n", (unsigned long) st.st_size);
fileoffset = st.st_size+1; /* skip a couple bytes to make sure the XML is don" */
fileoffset = (fileoffset + hwloc_getpagesize() - 1) &~(hwloc_getpagesize() - 1);
printf("will mmap at file offset %lu\n", fileoffset);
err = hwloc_shmem_topology_get_length(orig, &shmem_length, 0);
assert(!err);
printf("need mmap length %lu\n", (unsigned long) shmem_length);
#if SIZEOF_VOID_P == 8
forced_addr = 0x300000000000UL;
#else
forced_addr = 0xb0000000UL;
#endif
printf("write to shmem at address %lx in file %s offset %lu\n", forced_addr, tmpname, fileoffset);
err = hwloc_shmem_topology_write(orig, fd, fileoffset, (void*)(uintptr_t)forced_addr, shmem_length, 0);
if (err == -1 && errno == EBUSY) {
fprintf(stderr, "Failed to shmem write, requested mapping is busy\n");
goto out_with_fd;
}
assert(!err);
printf("wrote length %lu\n", (unsigned long) shmem_length);
printf("adopting locally\n");
ret = adopt(fd, fileoffset, forced_addr, shmem_length, synthetic_with_distances);
assert(ret == EXIT_SUCCESS || ret == EXIT_SKIP);
printf("adopting in other child process\n");
snprintf(cmd, sizeof(cmd), "%s %s %lu %lu %lu %d", callname, tmpname, fileoffset, forced_addr, (unsigned long) shmem_length, synthetic_with_distances);
printf("running command %s\n", cmd);
err = system(cmd);
assert(WIFEXITED(err));
printf("child process returned %d\n", WEXITSTATUS(err));
assert(WEXITSTATUS(err) == EXIT_SUCCESS || WEXITSTATUS(err) == EXIT_SKIP);
/* we caught errors above.
* return SKIP if both returned SKIP. otherwise SUCCESS
*/
if (WEXITSTATUS(err) == EXIT_SKIP && ret == EXIT_SKIP)
ret = EXIT_SKIP;
else
ret = EXIT_SUCCESS;
out_with_fd:
close(fd);
unlink(tmpname);
out:
return ret;
}
int main(int argc, char *argv[])
{
static hwloc_topology_t orig;
hwloc_obj_t nodes[3];
uint64_t node_distances[9];
unsigned i,j;
int err, ret, ret2;
if (argc > 1) {
int fd;
unsigned long forced_addr;
unsigned long fileoffset;
size_t shmem_length;
int synthetic_with_distances;
if (argc < 6) {
printf("needs 5 arguments\n");
return EXIT_FAILURE;
}
printf(" opening %s\n", argv[1]);
fd = open(argv[1], O_RDONLY);
if (fd < 0) {
perror("open");
return EXIT_FAILURE;
}
fileoffset = strtoul(argv[2], NULL, 0);
forced_addr = strtoul(argv[3], NULL, 0);
shmem_length = strtoul(argv[4], NULL, 0);
synthetic_with_distances = atoi(argv[5]);
ret = adopt(fd, fileoffset, forced_addr, shmem_length, synthetic_with_distances);
close(fd);
exit(ret);
}
printf("########################\n");
printf("creating native topology\n");
err = hwloc_topology_init(&orig);
assert(!err);
err = hwloc_topology_set_all_types_filter(orig, HWLOC_TYPE_FILTER_KEEP_ALL);
assert(!err);
err = hwloc_topology_load(orig);
assert(!err);
ret = test(orig, argv[0]);
printf("destroying original\n");
hwloc_topology_destroy(orig);
printf("###############################################\n");
printf("creating synthetic topo with distances topology\n");
err = hwloc_topology_init(&orig);
assert(!err);
err = hwloc_topology_set_synthetic(orig, "node:3 core:2 pu:4");
assert(!err);
err = hwloc_topology_load(orig);
assert(!err);
printf("adding distance matrix\n");
for(i=0; i<3; i++) {
nodes[i] = hwloc_get_obj_by_type(orig, HWLOC_OBJ_NUMANODE, i);
for(j=0; j<3; j++)
node_distances[i*3+j] = (i == j ? 10 : 20);
}
err = hwloc_distances_add(orig, 3, nodes, node_distances,
HWLOC_DISTANCES_KIND_MEANS_LATENCY|HWLOC_DISTANCES_KIND_FROM_USER,
HWLOC_DISTANCES_ADD_FLAG_GROUP);
assert(!err);
ret2 = test(orig, argv[0]);
printf("destroying original\n");
hwloc_topology_destroy(orig);
/* we caught errors above.
* return SKIP if both returned SKIP. otherwise SUCCESS
*/
if (ret == EXIT_SKIP && ret2 == EXIT_SKIP)
ret = EXIT_SKIP;
else
ret = EXIT_SUCCESS;
return ret;
}
QT_BEGIN_NAMESPACE
/*!
\class QEGLPlatformContext
\brief An EGL context implementation.
\since 5.2
\internal
\ingroup qpa
Implement QPlatformOpenGLContext using EGL. To use it in platform
plugins a subclass must be created since
eglSurfaceForPlatformSurface() has to be reimplemented. This
function is used for mapping platform surfaces (windows) to EGL
surfaces and is necessary since different platform plugins may
have different ways of handling native windows (for example, a
plugin may choose not to back every platform window by a real EGL
surface). Other than that, no further customization is necessary.
*/
// Constants from EGL_KHR_create_context
#ifndef EGL_CONTEXT_MINOR_VERSION_KHR
#define EGL_CONTEXT_MINOR_VERSION_KHR 0x30FB
#endif
#ifndef EGL_CONTEXT_FLAGS_KHR
#define EGL_CONTEXT_FLAGS_KHR 0x30FC
#endif
#ifndef EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR
#define EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR 0x30FD
#endif
#ifndef EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR
#define EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR 0x00000001
#endif
#ifndef EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR
#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR 0x00000002
#endif
#ifndef EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR
#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR 0x00000001
#endif
#ifndef EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR
#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR 0x00000002
#endif
// Constants for OpenGL which are not available in the ES headers.
#ifndef GL_CONTEXT_FLAGS
#define GL_CONTEXT_FLAGS 0x821E
#endif
#ifndef GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT
#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x0001
#endif
#ifndef GL_CONTEXT_FLAG_DEBUG_BIT
#define GL_CONTEXT_FLAG_DEBUG_BIT 0x00000002
#endif
#ifndef GL_CONTEXT_PROFILE_MASK
#define GL_CONTEXT_PROFILE_MASK 0x9126
#endif
#ifndef GL_CONTEXT_CORE_PROFILE_BIT
#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001
#endif
#ifndef GL_CONTEXT_COMPATIBILITY_PROFILE_BIT
#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
#endif
QEGLPlatformContext::QEGLPlatformContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share, EGLDisplay display,
EGLConfig *config, const QVariant &nativeHandle)
: m_eglDisplay(display)
, m_swapInterval(-1)
, m_swapIntervalEnvChecked(false)
, m_swapIntervalFromEnv(-1)
{
if (nativeHandle.isNull()) {
m_eglConfig = config ? *config : q_configFromGLFormat(display, format);
m_ownsContext = true;
init(format, share);
} else {
m_ownsContext = false;
adopt(nativeHandle, share);
}
}
/// Adaptor for above function. Also static function.
bool Shell::adopt( Id parent, Id child, unsigned int msgIndex ) {
return adopt( ObjId( parent ), child, msgIndex );
}
void
AdoptSegmentCommand::unexecute(void)
{
if (m_into) { unadopt(); }
else { adopt(); }
}
RTree::Node::Node( RTree::Trunk *parent ) {
this->bounds.init( this );
adopt( parent );
} /* ----- end of method RTree::Node::Node (constructor) ----- */
astree adopt2 (astree root, astree left, astree right) {
return adopt (root, left, right, NULL);
}
astree adopt1 (astree root, astree child) {
return adopt (root, child, NULL);
}
astree adopt3 (astree root, astree left, astree middle, astree right){
return adopt (root, left, middle, right, NULL);
}
computed_base &
computed_base::operator=( computed_base &&o )
{
adopt( std::move( o ) );
return *this;
}
computed_base::computed_base( computed_base &&o )
{
adopt( std::move( o ) );
}
