static KineticStatus KineticClient_CreateOperation(
    KineticOperation** operation,
    KineticSessionHandle handle)
{
    if (handle == KINETIC_HANDLE_INVALID) {
        LOG0("Specified session has invalid handle value");
        return KINETIC_STATUS_SESSION_EMPTY;
    }

    KineticConnection* connection = KineticConnection_FromHandle(handle);
    if (connection == NULL) {
        LOG0("Specified session is not associated with a connection");
        return KINETIC_STATUS_SESSION_INVALID;
    }

    LOGF1("\n"
         "--------------------------------------------------\n"
         "Building new operation on connection @ 0x%llX", connection);

    *operation = KineticAllocator_NewOperation(connection);
    if (*operation == NULL) {
        return KINETIC_STATUS_MEMORY_ERROR;
    }
    if ((*operation)->request == NULL) {
        return KINETIC_STATUS_NO_PDUS_AVAVILABLE;
    }

    return KINETIC_STATUS_SUCCESS;
}

void CMLauncherAppUi::PlaylistTransferCompleteL()
{
	LOG(ELogGeneral,1,"PlaylistTransferCompleteL: start");

	iActiveViews&=~EFiletransferViewActive;
	if(iCurrentView==iFiletransferView)
	{
		//we need to switch to a diferent vierw, e.g. list view
		LOG0("Activating list view");
		SwitchViewL(iListView);
		LOG0("List view activated");
	}/*
	else
	{
		//no need to switch view, but we must take care of the navi menu (may need replacing with exit)
		ChangeExitWithNaviL(-1);
	};*/

	Clean(ETrue);//this function performs asynchronously

    //update the view
    if(iDirection==EDirectionReceiving)
    	UpdateView();

	LOG(ELogGeneral,-1,"PlaylistTransferCompleteL: end");
};

/** @brief Log a message from the Python.
 *
 * In AQUAgpusph the Python stdout and stderr are redirected to this function,
 * such that:
 *     - stdout messages will be logged with level 0
 *     - stderr messages will be logged with level 3
 * @param self Module.
 * @param args Positional arguments.
 * @param keywds Keyword arguments.
 * @return Computed value, NULL if errors have been detected.
 */
static PyObject* logMsg(PyObject *self, PyObject *args, PyObject *keywds)
{
    int level;
    const char* msg;

    static char *kwlist[] = {"log_level", "message", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, keywds, "is", kwlist,
                                     &level, &msg)){
        return NULL;
    }

    switch(level) {
        case 0:
            LOG0(Aqua::L_DEBUG, msg); break;
        case 1:
            LOG0(Aqua::L_INFO, msg); break;
        case 2:
            LOG0(Aqua::L_WARNING, msg); break;
        case 3:
            LOG0(Aqua::L_ERROR, msg); break;            
    }

    Py_RETURN_NONE;
}

void KineticController_HandleUnexpectedResponse(void *msg,
        int64_t seq_id,
        void *bus_udata,
        void *socket_udata)
{
    KineticResponse * response = msg;
    KineticSession* session = socket_udata;
    bool connetionInfoReceived = false;
    char const * statusTag = "[PDU RX STATUS]";
    char const * unexpectedTag = "[PDU RX UNEXPECTED]";
    char const * logTag = unexpectedTag;
    int logAtLevel, protoLogAtLevel;

    (void)bus_udata;

    // Handle unsolicited status PDUs
    if (response->proto->authtype == COM__SEAGATE__KINETIC__PROTO__MESSAGE__AUTH_TYPE__UNSOLICITEDSTATUS) {
        int64_t connectionID = KineticResponse_GetConnectionID(response);
        if (connectionID != 0)
        {
            // Store connectionID from unsolicited status message in the session for future requests
            KineticSession_SetConnectionID(session, connectionID);
            LOGF2("Extracted connection ID from unsolicited status PDU (id=%lld)", connectionID);
            connetionInfoReceived = true;
            logTag = statusTag;
            logAtLevel = 2;
            protoLogAtLevel = 3;
        }
        else {
            LOG0("WARNING: Unsolicited status received. Connection being terminated by remote!");
            logTag = statusTag;
            logAtLevel = 0;
            protoLogAtLevel = 0;
            KineticStatus status = KineticResponse_GetStatus(response);
            KineticSession_SetTerminationStatus(session, status);
        }
    }
    else {
        LOG0("WARNING: Received unexpected response!");
        logTag = unexpectedTag;
        logAtLevel = 0;
        protoLogAtLevel = 0;
    }

    KineticLogger_LogPrintf(logAtLevel, "%s pdu: %p, session: %p, bus: %p, "
                            "fd: %6d, seq: %8lld, protoLen: %8u, valueLen: %8u",
                            logTag,
                            (void*)response, (void*)session,
                            (void*)session->messageBus,
                            session->socket, (long long)seq_id,
                            KineticResponse_GetProtobufLength(response),
                            KineticResponse_GetValueLength(response));
    KineticLogger_LogProtobuf(protoLogAtLevel, response->proto);

    KineticAllocator_FreeKineticResponse(response);

    if (connetionInfoReceived) {
        KineticResourceWaiter_SetAvailable(&session->connectionReady);
    }
}

KineticStatus KineticSession_Create(KineticSession * const session, KineticClient * const client)
{
    if (session == NULL) {
        LOG0("Session is NULL");
        return KINETIC_STATUS_SESSION_EMPTY;
    }

    if (client == NULL) {
        LOG0("Client is NULL");
        return KINETIC_STATUS_SESSION_EMPTY;
    }

    session->connected = false;
    session->socket = KINETIC_SOCKET_INVALID;

    // initialize session send mutex
    if (pthread_mutex_init(&session->sendMutex, NULL) != 0) {
        LOG0("Failed initializing session send mutex!");
        return KINETIC_STATUS_MEMORY_ERROR;
    }

    session->outstandingOperations =
        KineticCountingSemaphore_Create(KINETIC_MAX_OUTSTANDING_OPERATIONS_PER_SESSION);
    if (session->outstandingOperations == NULL) {
        LOG0("Failed creating session counting semaphore!");
        return KINETIC_STATUS_MEMORY_ERROR;
    }

    return KINETIC_STATUS_SUCCESS;
}

bool IODicom<T>::ReadMetaData(PGCore::BaseDataObject *oMetaDataObject, const IOParams &iParams)
{
    const std::vector<std::string>& iPaths = iParams.Source();
    if (iPaths.empty())
    {
        LOG0("IO/IODicom::ReadMetaData: Invalid input filename vector.");
        return false;
    }
    const std::string &iFileName = iPaths[0];
    if (iFileName.empty())
    {
        LOG0("IO/IODicom::ReadMetaData: Invalid input filename.");
        return false;
    }

    //this is where to read the image in
    PGCore::MetaData<T> *oMetaData = (static_cast<PGCore::MetaData< T > *>(oMetaDataObject));
    if (!oMetaData)
    {
        LOG0("IO/IOBase::ReadMetaData: Invalid output container for metadata.");
        return false;
    }

    return GetAttributes(*oMetaData, iFileName);
}

SQLCode::SQLCode()
{
	LOG0(SourceInfo, DebugUtil::DebugSQL,"Begin build the Hash table...");

	m_pSqlFileHelper = new SQLFileHelper();

	LOG0(SourceInfo, DebugUtil::DebugSQL,"End build the Hash table...");
}

KineticStatus KineticClient_DestroySession(KineticSession* const session)
{
    if (session == NULL) {
        LOG0("KineticSession is NULL!");
        return KINETIC_STATUS_SESSION_INVALID;
    }

    KineticStatus status = KineticSession_Disconnect(session);
    if (status != KINETIC_STATUS_SUCCESS) {LOG0("Disconnection failed!");}
    KineticSession_Destroy(session);

    return status;
}

KineticStatus KineticSession_Connect(KineticSession * const session)
{
    if (session == NULL) {
        return KINETIC_STATUS_SESSION_EMPTY;
    }

    // Establish the connection
    KINETIC_ASSERT(strlen(session->config.host) > 0);
    session->socket = KineticSocket_Connect(
        session->config.host, session->config.port);
    if (session->socket == KINETIC_SOCKET_DESCRIPTOR_INVALID) {
        LOG0("Session connection failed!");
        session->socket = KINETIC_SOCKET_DESCRIPTOR_INVALID;
        session->connected = false;
        return KINETIC_STATUS_CONNECTION_ERROR;
    }
    session->connected = true;

    bus_socket_t socket_type = session->config.useSsl ? BUS_SOCKET_SSL : BUS_SOCKET_PLAIN;
    session->si = calloc(1, sizeof(socket_info) + 2 * PDU_PROTO_MAX_LEN);
    if (session->si == NULL) { return KINETIC_STATUS_MEMORY_ERROR; }
    bool success = Bus_RegisterSocket(session->messageBus, socket_type, session->socket, session);
    if (!success) {
        LOG0("Failed registering connection with client!");
        goto connection_error_cleanup;
    }

    // Wait for initial unsolicited status to be received in order to obtain connection ID
    success = KineticResourceWaiter_WaitTilAvailable(&session->connectionReady, KINETIC_CONNECTION_TIMEOUT_SECS);
    if (!success) {
        LOG0("Timed out waiting for connection ID from device!");
        goto connection_error_cleanup;
    }
    LOGF1("Received connection ID %lld for session %p",
        (long long)KineticSession_GetConnectionID(session), (void*)session);

    return KINETIC_STATUS_SUCCESS;

connection_error_cleanup:

    if (session->si != NULL) {
        free(session->si);
        session->si = NULL;
    }
    if (session->socket != KINETIC_SOCKET_DESCRIPTOR_INVALID) {
        KineticSocket_Close(session->socket);
        session->socket = KINETIC_SOCKET_DESCRIPTOR_INVALID;
    }
    session->connected = false;
    return KINETIC_STATUS_CONNECTION_ERROR;
}

        void gInitStructuredExceptionHandler()
        {
            // TODO LPP: Should we use a thread local variable to ensure we only call
            // _set_se_translator() once per thread?  Does _set_se_translator() already do this?

            static bool shouldSetSeTranslator = RunParams::getInstance().isSet(RPARAM_DEBUGLOGSTACKTRACE);
            if (shouldSetSeTranslator)
            {
                LOG0(SourceInfo, DebugUtil::DebugDebug, "gInitStructuredExceptionHandler(): calling _set_se_translator()");
                _set_se_translator( translator_func );
            }
            else
            {
                LOG0(SourceInfo, DebugUtil::DebugDebug, "gInitStructuredExceptionHandler(): NOT calling _set_se_translator()");
            }
        }

BOOL CAuthenticationPg::OnInitDialog() {
	LOG0(3, "CAuthenticationPg::OnInitDialog()");

	CPropertyPage::OnInitDialog();

	return TRUE;
}

//---------------------------------------------------------------------------
//
//	セーブ
//
//---------------------------------------------------------------------------
int FASTCALL CRTC::Save(Fileio *fio, int ver)
{
	size_t sz;

	ASSERT(this);
	ASSERT(fio);
	LOG0(Log::Normal, "セーブ");

	// サイズをセーブ
	sz = sizeof(crtc_t);
	if (!fio->Write(&sz, sizeof(sz))) {
		return FALSE;
	}

	// 実体をセーブ
	if (!fio->Write(&crtc, (int)sz)) {
		return FALSE;
	}

	// イベントをセーブ
	if (!event.Save(fio, ver)) {
		return FALSE;
	}

	return TRUE;
}

	bool ErosionKernel<T, U>::Initialize_()
	{
		if (m_radius<=0.0f)
		{
			return false;
		}

		// fill up the buffer here
		int i=0;

		// fill circle

		
		/*for (i=0;i<(m_dimension);i++) 
		{
			SetValue(0, i, 1);
		}*/
		
		bool res = drawCircle(m_dimension/2, m_dimension/2, m_radius, m_buffer);
		if (!res) return false;

#ifdef _DEBUG
		if (0)
		{
			LOG1("The filter coefficients are (radius: %d):", m_radius);
			for(int j=0;j<(m_dimension);j++)
			{
				LOG0("\n");
				for(i=0;i<(m_dimension);i++)
					LOG3("Kernel[%d][%d] = %f", j, i, (double)GetValue(j, i));
			}
		}
#endif
		return true;
	}

void CPropCachingPg::UpdateControls() {
	LOG0(3, "CPropCachingPg::UpdateControls()");

	if (m_ctlSpecificCaching.GetCheck() == BST_CHECKED) {
		m_ctlStoreImages.EnableWindow();
		m_ctlCacheOnlineContent.EnableWindow();
	}
	else {
		m_ctlStoreImages.EnableWindow(FALSE);
		m_ctlCacheOnlineContent.EnableWindow(FALSE);
	}

	if (m_ctlCacheEnclosures.GetCheck() == BST_CHECKED) {
		m_ctlEnclosureLimit.EnableWindow();
		m_ctlLargerLbl.EnableWindow();
		m_ctlEnclosureLimitSpin.EnableWindow();
		m_ctlMB.EnableWindow();
		m_ctlMBLbl.EnableWindow();
	}
	else {
		m_ctlEnclosureLimit.EnableWindow(FALSE);
		m_ctlLargerLbl.EnableWindow(FALSE);
		m_ctlEnclosureLimitSpin.EnableWindow(FALSE);
		m_ctlMB.EnableWindow(FALSE);
		m_ctlMBLbl.EnableWindow(FALSE);
	}
}

	//  0: false, not in async mode
	//  1: true
	int AsyncProcess::NotifyError(const char *iMsg/*=0*/)
	{
		if (!m_pProcess) return false;
		if (!m_pProcess->GetAsyncEnabled()) return false;
		//if (!ioAsyncLoadMT) return 0;

		EnterCriticalSection(&m_csMT);
		m_threadsRemaining--;
		LeaveCriticalSection(&m_csMT);
		
		if (m_threadsRemaining>0) 
		{
			LOG1("%d threads remaining. One of them reported error. Killing all..", m_threadsRemaining);
		} else
		{
			LOG0("A thread reported error. Killing all..");
		}

		for (int i=0; i<m_numThreadsMT; i++)
		{				
			//if (m_thread[i].IsAlive())
			{					
				m_thread[i].CloseThread();
				LOG1("Closed thread with threadHandle [%d]", m_hThreadMT[i]);
			}
		}

		return 1;
	}

BOOL CRewriteRuleDlg::OnInitDialog() {
	LOG0(3, "CRewriteRuleDlg::OnInitDialog()");

	CCeDialog::OnInitDialog();

	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

CRewriteRuleDlg::CRewriteRuleDlg(CWnd* pParent /*=NULL*/)
	: CCeDialog(CRewriteRuleDlg::IDD)
{
	LOG0(5, "CRewriteRuleDlg::CRewriteRuleDlg()");
	//{{AFX_DATA_INIT(CRewriteRuleDlg)
	//}}AFX_DATA_INIT
	SetMenu(IDR_DONE);
}

bool ImageEdgeDetectionBase<T, U>::Execute() {

    if (!m_iDataObject) {
        LOG0("ImageEdgeDetectionBase: Error: no input");
        return false;
    }

    // also check base image types here

    // get first image
    PGCore::Image<T> *inImage = (static_cast<PGCore::Image < T > *>(m_iDataObject));
    if (!inImage) {
        LOG0("ImageEdgeDetectionBase: Error: failure to fetch input image");
        return false;
    }

    long iRows=0, iColumns=0;
    inImage->GetDimensions(iRows, iColumns);
    if (iRows*iColumns <=0) {
        LOG0("ImageEdgeDetectionBase: Error: invalid image size");
        return false;
    }

    const T* inBuf = inImage->GetBuffer();
    if (!inBuf)
    {
        LOG0("ImageEdgeDetectionBase: Error: invalid image");
        return false;
    }

    if (m_oImageObject == NULL)
        m_oImageObject = new PGCore::Image<U>(iRows, iColumns);
    U* outBuf = m_oImageObject->GetBuffer();
    if (!outBuf)
    {
        LOG0("ImageEdgeDetectionBase: Error: invalid out image");
        return false;
    }

    bool rv = detectEdges(m_sigma, m_loTh, m_hiTh, inImage, m_oImageObject);

    m_oDataObject = (static_cast<PGCore::BaseDataObject *>(m_oImageObject));

    return rv;
}

CString MakeOfflineUrl(const CString &strFileName) {
	LOG0(5, "MakeOfflineUrl()");

	CString strOfflineUrl;
	strOfflineUrl.Format(_T("file://localhost%s"), strFileName);
	strOfflineUrl.Replace('\\', '/');

	return strOfflineUrl;
}

void tearDown(void)
{
    if (FileDesc >= 0) {
        LOG0("Shutting down socket...");
        KineticSocket_Close(FileDesc);
        FileDesc = 0;
    }
    KineticLogger_Close();
}