305 lines
13 KiB
C++
305 lines
13 KiB
C++
// CkGlobal.h: interface for the CkGlobal class.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// This header is generated for Chilkat 11.3.0
|
|
|
|
#define _CkVersion 11.3.0
|
|
|
|
#ifndef _CkGlobal_H
|
|
#define _CkGlobal_H
|
|
|
|
#include "chilkatDefs.h"
|
|
#include "CkString.h"
|
|
#include "CkMultiByteBase.h"
|
|
|
|
|
|
|
|
|
|
#if !defined(__sun__) && !defined(__sun)
|
|
#pragma pack (push, 8)
|
|
#endif
|
|
|
|
|
|
#undef Copy
|
|
|
|
// CLASS: CkGlobal
|
|
class CK_VISIBLE_PUBLIC CkGlobal : public CkMultiByteBase
|
|
{
|
|
private:
|
|
|
|
// Don't allow assignment or copying these objects.
|
|
CkGlobal(const CkGlobal &);
|
|
CkGlobal &operator=(const CkGlobal &);
|
|
|
|
public:
|
|
CkGlobal(void);
|
|
virtual ~CkGlobal(void);
|
|
|
|
static CkGlobal *createNew(void);
|
|
static CkGlobal *createNew2(int progLang);
|
|
void CK_VISIBLE_PRIVATE inject(void *impl);
|
|
|
|
// May be called when finished with the object to free/dispose of any
|
|
// internal resources held by the object.
|
|
void dispose(void);
|
|
|
|
|
|
|
|
|
|
|
|
// BEGIN PUBLIC INTERFACE
|
|
|
|
// ----------------------
|
|
// Properties
|
|
// ----------------------
|
|
// The default ANSI code page is determined at runtime based on the computer where
|
|
// the application happens to be running. For example, the ANSI code page for an
|
|
// application running on a Japanese computer is likely to be Shift_JIS (code page
|
|
// 932), whereas on a US-English computer it would be iso-8859-1 (or Windows-1252
|
|
// which is essentially a superset of iso-8859-1).
|
|
//
|
|
// If there is a desire for the Chilkat library to use a specific ANSI code page
|
|
// regardless of locale, then this property should be set to the desired code page.
|
|
// The default value of this property is the ANSI code page of the local computer.
|
|
//
|
|
int get_AnsiCodePage(void);
|
|
// The default ANSI code page is determined at runtime based on the computer where
|
|
// the application happens to be running. For example, the ANSI code page for an
|
|
// application running on a Japanese computer is likely to be Shift_JIS (code page
|
|
// 932), whereas on a US-English computer it would be iso-8859-1 (or Windows-1252
|
|
// which is essentially a superset of iso-8859-1).
|
|
//
|
|
// If there is a desire for the Chilkat library to use a specific ANSI code page
|
|
// regardless of locale, then this property should be set to the desired code page.
|
|
// The default value of this property is the ANSI code page of the local computer.
|
|
//
|
|
void put_AnsiCodePage(int newVal);
|
|
|
|
// If set to true, then Q or B encoded strings can be passed in any string
|
|
// argument to any Chilkat method, and Chilkat will automatically decode the string
|
|
// before using it. This is meant to be a convenient way to use non-usascii literal
|
|
// strings in your source code. See the links below for an example and for a
|
|
// discussion about non-usascii literal strings.
|
|
bool get_AutoQBDecode(void);
|
|
// If set to true, then Q or B encoded strings can be passed in any string
|
|
// argument to any Chilkat method, and Chilkat will automatically decode the string
|
|
// before using it. This is meant to be a convenient way to use non-usascii literal
|
|
// strings in your source code. See the links below for an example and for a
|
|
// discussion about non-usascii literal strings.
|
|
void put_AutoQBDecode(bool newVal);
|
|
|
|
// Selects the default NTLM protocol version to use for NTLM authentication for
|
|
// HTTP, POP3, IMAP, SMTP, and HTTP proxies. The default value is 2. This property
|
|
// may optionally be set to 1.
|
|
int get_DefaultNtlmVersion(void);
|
|
// Selects the default NTLM protocol version to use for NTLM authentication for
|
|
// HTTP, POP3, IMAP, SMTP, and HTTP proxies. The default value is 2. This property
|
|
// may optionally be set to 1.
|
|
void put_DefaultNtlmVersion(int newVal);
|
|
|
|
// Sets the default value of the Utf8 property for each Chilkat class.
|
|
//
|
|
// In Chilkat v11.0.0 and later, the default value is true. Before v11.0.0, it
|
|
// was false.
|
|
//
|
|
bool get_DefaultUtf8(void);
|
|
// Sets the default value of the Utf8 property for each Chilkat class.
|
|
//
|
|
// In Chilkat v11.0.0 and later, the default value is true. Before v11.0.0, it
|
|
// was false.
|
|
//
|
|
void put_DefaultUtf8(bool newVal);
|
|
|
|
// If DNS caching is enabled, this is the time-to-live (in seconds) for a cached
|
|
// DNS lookup. A DNS lookup result older than this expiration time is discarded,
|
|
// and causes a new DNS lookup to occur. A value of 0 indicates an infinite
|
|
// time-to-live. The default value of this property is 0.
|
|
int get_DnsTimeToLive(void);
|
|
// If DNS caching is enabled, this is the time-to-live (in seconds) for a cached
|
|
// DNS lookup. A DNS lookup result older than this expiration time is discarded,
|
|
// and causes a new DNS lookup to occur. A value of 0 indicates an infinite
|
|
// time-to-live. The default value of this property is 0.
|
|
void put_DnsTimeToLive(int newVal);
|
|
|
|
// Controls whether DNS domain lookups (to resolve to IP addresses) are cached in
|
|
// memory. The default value is false, meaning that DNS caching is disabled.
|
|
bool get_EnableDnsCaching(void);
|
|
// Controls whether DNS domain lookups (to resolve to IP addresses) are cached in
|
|
// memory. The default value is false, meaning that DNS caching is disabled.
|
|
void put_EnableDnsCaching(bool newVal);
|
|
|
|
// The maximum number of thread pool threads. The default value is 100. The maximum
|
|
// value is 500. Note: Asynchronous worker threads are created on as needed up to
|
|
// the maximum.
|
|
int get_MaxThreads(void);
|
|
// The maximum number of thread pool threads. The default value is 100. The maximum
|
|
// value is 500. Note: Asynchronous worker threads are created on as needed up to
|
|
// the maximum.
|
|
void put_MaxThreads(int newVal);
|
|
|
|
// If true, then use IPv6 over IPv4 when both are supported for a particular
|
|
// domain. The default value of this property is false, which will choose IPv4
|
|
// over IPv6.
|
|
//
|
|
// Note: Setting this property has the effect of also setting the default value of
|
|
// the PreferIpv6 property for other classes.
|
|
//
|
|
bool get_PreferIpv6(void);
|
|
// If true, then use IPv6 over IPv4 when both are supported for a particular
|
|
// domain. The default value of this property is false, which will choose IPv4
|
|
// over IPv6.
|
|
//
|
|
// Note: Setting this property has the effect of also setting the default value of
|
|
// the PreferIpv6 property for other classes.
|
|
//
|
|
void put_PreferIpv6(bool newVal);
|
|
|
|
// If set, indicates the path of a log file to be used by the thread pool thread
|
|
// and each of the pool worker threads for logging async activity. Chilkat always
|
|
// appends to the log file. If the log file already exists, then new information
|
|
// will be appended.
|
|
void get_ThreadPoolLogPath(CkString &str);
|
|
// If set, indicates the path of a log file to be used by the thread pool thread
|
|
// and each of the pool worker threads for logging async activity. Chilkat always
|
|
// appends to the log file. If the log file already exists, then new information
|
|
// will be appended.
|
|
const char *threadPoolLogPath(void);
|
|
// If set, indicates the path of a log file to be used by the thread pool thread
|
|
// and each of the pool worker threads for logging async activity. Chilkat always
|
|
// appends to the log file. If the log file already exists, then new information
|
|
// will be appended.
|
|
void put_ThreadPoolLogPath(const char *newVal);
|
|
|
|
// This is a catch-all property to be used for uncommon needs. This property
|
|
// defaults to the empty string, and should typically remain empty.
|
|
void get_UncommonOptions(CkString &str);
|
|
// This is a catch-all property to be used for uncommon needs. This property
|
|
// defaults to the empty string, and should typically remain empty.
|
|
const char *uncommonOptions(void);
|
|
// This is a catch-all property to be used for uncommon needs. This property
|
|
// defaults to the empty string, and should typically remain empty.
|
|
void put_UncommonOptions(const char *newVal);
|
|
|
|
// Indicates the unlocked status for the last call to UnlockBundle. The possible
|
|
// values are:
|
|
// 1. Not unlocked. (Still in locked state.)
|
|
// 2. Unlocked with in fully-functional trial mode.
|
|
// 3. Unlocked using a valid purchased unlock code.
|
|
//
|
|
// Note: If UnlockBundle is called with a purchased unlock code, the UnlockStatus
|
|
// is correctly set to the value 2. This value is intentionally sticky. If a
|
|
// subsequent and redundant call to UnlockBundle happens, it is effectively a No-Op
|
|
// because the library is already unlocked. The UnlockStatus will not change.
|
|
//
|
|
// If however, if the 1st call resulted in UnlockStatus = 1, and THEN the unlock
|
|
// method is called again with a purchased unlock code, the UnlockStatus should
|
|
// change from 1 to 2.
|
|
//
|
|
int get_UnlockStatus(void);
|
|
|
|
// This property should typically be left at the default value of false. If set
|
|
// to true, then Chilkat will use a constructed ASN.1 encoding for PCKS7 data.
|
|
// (This is an internal implementation option that normally does not matter, and
|
|
// should not matter. Some PKCS7 receiving systems might be picky, and this option
|
|
// can be used to satisfy this requirement.)
|
|
bool get_UsePkcsConstructedEncoding(void);
|
|
// This property should typically be left at the default value of false. If set
|
|
// to true, then Chilkat will use a constructed ASN.1 encoding for PCKS7 data.
|
|
// (This is an internal implementation option that normally does not matter, and
|
|
// should not matter. Some PKCS7 receiving systems might be picky, and this option
|
|
// can be used to satisfy this requirement.)
|
|
void put_UsePkcsConstructedEncoding(bool newVal);
|
|
|
|
// If set to true, then causes extremely verbose logging (in LastErrorText) all
|
|
// TLS connections in any Chilkat class. This property should only be used for
|
|
// troubleshooting TLS problems. The default value is false.
|
|
//
|
|
// Note: This property only has effect on Chilkat objects not yet created. Set the
|
|
// property first, then instantiate the Chilkat object.
|
|
//
|
|
bool get_VerboseTls(void);
|
|
// If set to true, then causes extremely verbose logging (in LastErrorText) all
|
|
// TLS connections in any Chilkat class. This property should only be used for
|
|
// troubleshooting TLS problems. The default value is false.
|
|
//
|
|
// Note: This property only has effect on Chilkat objects not yet created. Set the
|
|
// property first, then instantiate the Chilkat object.
|
|
//
|
|
void put_VerboseTls(bool newVal);
|
|
|
|
|
|
|
|
// ----------------------
|
|
// Methods
|
|
// ----------------------
|
|
// This function clears the Chilkat in-memory DNS cache, which stores
|
|
// hostname-to-IP address mappings to avoid repeated DNS lookups.
|
|
//
|
|
// Note:
|
|
//
|
|
// * The DNS cache is shared across all Chilkat objects, so clearing it will
|
|
// impact all such objects.
|
|
// * Chilkat's DNS caching respects the TTL (time to live) of DNS records. If
|
|
// the TTL has expired since the initial lookup, Chilkat will perform a new DNS
|
|
// query and update the cache with the latest IP address.
|
|
bool DnsClearCache(void);
|
|
|
|
|
|
// Called to stop and finalize all threads in the thread pool, and causes the
|
|
// thread pool thread to exit.
|
|
//
|
|
// The following behaviors exist in v9.5.0.64 and later:
|
|
// * All remaining asynchronous tasks are automatically canceled.
|
|
// * Restores the thread pool to it's pristine state where no background
|
|
// threads are running.
|
|
//
|
|
// It is a good idea to call this method at the very end of a program, just before
|
|
// it exits. This is especially true for programs written in VBScript, VB6, FoxPro,
|
|
// and PowerBuilder.
|
|
//
|
|
bool FinalizeThreadPool(void);
|
|
|
|
|
|
// Logs a line to the thread pool log file.
|
|
bool ThreadPoolLogLine(const char *str);
|
|
|
|
|
|
// Unlocks the entire Chilkat API for all classes. This should be called once at
|
|
// the beginning of a program. Once unlocked, objects of any Chilkat class may be
|
|
// instantiated and used. To unlock in fully-functional 30-day trial mode, pass any
|
|
// string, such as Hello , in bundleUnlockCode. If a license is purchased, then replace the
|
|
// Hello with the purchased unlock code.
|
|
//
|
|
// After calling UnlockBundle once, the instance of the CLASS_NAME object may be
|
|
// discarded/deleted (assuming the programming language requires explicit deletes).
|
|
// Multiple calls to UnlockBundle are harmless. If the Chilkat API is already
|
|
// unlocked, the duplicate calls to UnlockBundle are no-ops.
|
|
//
|
|
// Important: Unlocking sets a flag in memory to indicate the unlocked status.
|
|
// There are no licensing files, and there is no communication with any Chilkat
|
|
// servers. This means your application, script, etc. must call UnlockBundle once
|
|
// at the start each time it runs. The good thing is that your application can run
|
|
// on any computer -- there are no licensing files to worry about. Also: If an
|
|
// application forgets to call UnlockBundle, Chilkat will automatically unlock in
|
|
// trial mode, and this will eventually fail when the trial runs out. If you
|
|
// purchased a license, it is very important to make sure you call UnlockBundle
|
|
// with the purchased unlock code.
|
|
//
|
|
bool UnlockBundle(const char *bundleUnlockCode);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// END PUBLIC INTERFACE
|
|
|
|
|
|
};
|
|
#if !defined(__sun__) && !defined(__sun)
|
|
#pragma pack (pop)
|
|
#endif
|
|
|
|
#endif
|