// 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
