text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>//
// Ascii.h
//
// Library: Foundation
// Package: Core
// Module: Ascii
//
// Definition of the Ascii class.
//
// Copyright (c) 2010, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Ascii_INCLUDED
#define Foundation_Asc... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Asyn<|fim_suffix|>:string & value);
/// Sets or changes a configuration property.
///
/// The "channel" property allows setting the target
/// channel via the LoggingRegistry.
/// The "channel" property is set-only.
///
/// The "priority" property allows setting the threa... | fim | ClickHouse/ClickHouse | c |
//
// AtomicCounter.h
//
// Library: Foundation
// Package: Core
// Module: AtomicCounter
//
// Definition of the AtomicCounter class.
//
// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_AtomicCounter_INCLUDED
#def... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// AutoPtr.h
//
// Library: Foundation
// Package: Core
// Module: AutoPtr
//
// Definition of the AutoPtr template class.
//
// Copyright (c) 2004-2006<|fim_suffix|>AutoPtr & ptr) const { return _ptr <= ptr._ptr; }
bool operator<=(const C * ptr) const { return _ptr <= ptr; }
bool operator<=... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
/// The object's reference count is not modified
{
if (pObject)
_list.push_back(pObject);
}
void release()
/// Releases all objects the AutoReleasePool currently holds
/// by calling each object's release() method.
{
while (!_list.empty())
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>IT;
private:
Base64DecoderBuf(const Base64DecoderBuf &);
Base64DecoderBuf & operator=(const Base64DecoderBuf &);
};
class Foundation_API Base64DecoderIOS : public virtual std::ios
/// The base class for Base64Decoder.
///
/// This class is needed to ensure the correct initialization
/// order o... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Base64Encoder.h
//
// Library: Foundation
// Package: Streams
// Module: Base64
//
// Definition of class Base64Encoder.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Base64Encoder_IN... | fim | ClickHouse/ClickHouse | c |
//
// BasicEvent.h
//
// Library: Foundation
// Package: Events
// Module: BasicEvent
//
// Implementation of the BasicEvent template.
//
// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_BasicEvent_INCLUDED
#d... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// BinaryReader.h
//
// Library: Foundation
// Package: Streams
// Module: BinaryReaderWriter
//
// Definition of the BinaryReader class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Bi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// BinaryWriter.h
//
// Library: Foundation
// Package: Streams
// Module: BinaryReaderWriter
//
// Definition of the BinaryWriter class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Bi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Buffer.h
//
// Library: Foundation
// Package: Core
// Module: Buffer
//
// Definition of the Buffer class.
//
// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Buffer_INCLUDED
#define Foundation... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> specific
/// BufferAllocator has been specified.
{
public:
typedef ch char_type;
static char_type * allocate(std::streamsize size) { return new char_type[static_cast<std::size_t>(size)]; }
static void deallocate(char_type * ptr, std::streamsize /*size*/) throw() { delete[] ptr; }
};
} // ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>on_BufferedBidirectionalStreamBuf_INCLUDED
<|fim_prefix|>//
// BufferedBidirectionalStreamBuf.h
//
// Library: Foundation
// Package: Streams
// Module: StreamBuf
//
// Definition of template BasicBufferedBidirectionalStreamBuf and class BufferedBidirectionalStreamBuf.
//
// Copyright (c) 2005-2006, Appl... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>p(-n);
return n;
}
std::streamsize _bufsize;
char_type * _pBuffer;
openmode _mode;
BasicBufferedStreamBuf(const BasicBufferedStreamBuf &);
BasicBufferedStreamBuf & operator=(const BasicBufferedStreamBuf &);
};
//
// We provide an instantiation for char.
//
// Visual C++... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Bugcheck.h
//
// Library: Foundation
// Package: Core
// Module: Bugcheck
//
// Definition of the Bugcheck class and the self-testing macros.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Founda... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>t32 value)
{
return Int32(flipBytes(UInt32(value)));
}
inline UInt64 ByteOrder::flipBytes(UInt64 value)
{
# if defined(POCO_HAVE_MSC_BYTESWAP)
return _byteswap_uint64(value);
# elif defined(POCO_HAVE_GCC_BYTESWAP)
return __builtin_bswap64(value);
# else
UInt32 hi = UInt32(value ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Channel.h
//
// Library: Foundation
// Package: Logging
// Module: Channel
//
// Definition of the Channel class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
<|fim_suffix|>rtual ~Channel();
private:
C... | fim | ClickHouse/ClickHouse | c |
//
// Checksum.h
//
// Library: Foundation
// Package: Core
// Module: Checksum
//
// Definition of the Checksum class.
//
// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Checksum_INCLUDED
#define Foundation_Check... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>k;
}
inline Clock::ClockDiff Clock::elapsed() const
{
Clock now;
return now - *this;
}
inline bool Clock::isElapsed(Clock::ClockDiff interval) const
{
Clock now;
Clock::ClockDiff diff = now - *this;
return diff >= interval;
}
inline Clock::ClockDiff Clock::resolution()
{
retu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>lon));
pos = comma_after_colon + 1;
return res;
}
/// Returns true if it's "never" or false if not.
static bool parseNever(std::string_view str)
{
return str == "never";
}
/// Support 100M/10 minutes/100M,10 minutes
RotationInfo parseRotation(std::stri... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// CompressedLogFile.h
//
// Library: Foundation
// Package: Logging
// Module: CompressedLogFile
//
// Definition of the LogFile class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Com... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Condition.h
//
// Library: Foundation
// Package: Threading
// Module: Condition
//
// Definition of the Condition class template.
//
// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-<|fim_suffix|>;
Event event;
{
Fast... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Config.h
//
// Library: Foundation
// Package: Core
// Module: Foundation
//
// Feature configuration for the POCO libraries.
//
// Copyright (c) 2006-2016, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Config_INCL... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Configurable.h
//
// Library: Foundation
// Package: Logging
// Module: Configurable
//
// Definition of the Configurable class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Configur... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// ConsoleChannel.h
//
// Library: Foundation
// Package: Logging
// Module: ConsoleChannel
//
// Definition of the ConsoleChannel class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Co... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// CountingStream.h
//
// Library: Foundation
// Package: Streams
// Module: CountingStream
//
// Definition of the CountingStreamBuf, CountingInputStream and CountingOutputStream classes.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-Lic... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// DateTime.h
//
// Library: Foundation
// Package: DateTime
// Module: DateTime
//
// Definition of the DateTime class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_DateTime_INCLUDED
#... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ormat.
///
/// Example:
/// 2005-01-01 12:00:00
// names used by formatter and parser
static const std::string WEEKDAY_NAMES[7];
/// English names of week days (Sunday, Monday, Tuesday, ...).
static const std::string MONTH_NAMES[12];
/// English names of months (Januar... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// DateTimeFormatter.h
//
// Library: Foundation
// Package: DateTime
// Module: DateTimeFormatter
//
// Definition of the DateTimeFormatter class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Fou... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// DateTimeParser.h
//
// Library: Foundation
// Package: DateTime
// Module: DateTimeParser
//
// Definition of the DateTimeParser class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_D... | fim | ClickHouse/ClickHouse | c |
//
// Debugger.h
//
// Library: Foundation
// Package: Core
// Module: Debugger
//
// Definition of the Debugger class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Debugger_INCLUDED
#define Foundation_... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// DefaultStrategy.h
//
// Library: Foundation
// Package: Events
// Module: De<|fim_suffix|>urn pDelegate.get();
}
void remove(const TDelegate & delegate)
{
for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
{
if (delegate.equals(**it))
... | fim | ClickHouse/ClickHouse | c |
//
// DeflatingStream.h
//
// Library: Foundation
// Package: Streams
// Module: ZLibStream
//
// Definition of the DeflatingStream class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_DeflatingStream_IN... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|><TArgs, true, false>(NotifyMethod);
}
template <class TArgs>
inline FunctionDelegate<TArgs, false> delegate(void (*NotifyMethod)(TArgs &))
{
return FunctionDelegate<TArgs, false>(NotifyMethod);
}
template <class TObj>
class Delegate<TObj, void, true> : public AbstractDelegate<void>
{
public:
t... | fim | ClickHouse/ClickHouse | c |
//
// DigestEngine.h
//
// Library: Foundation
// Package: Crypt
// Module: DigestEngine
//
// Definition of class DigestEngine.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_DigestEngine_INCLUDED
#defin... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>es.
{
public:
DigestIOS(DigestEngine & eng);
DigestIOS(DigestEngine & eng, std::istream & istr);
DigestIOS(DigestEngine & eng, std::ostream & ostr);
~DigestIOS();
DigestBuf * rdbuf();
protected:
DigestBuf _buf;
};
class Foundation_API DigestInputStream : public DigestIOS, public... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ile * DirectoryIterator::operator->()
{
return &_file;
}
inline bool DirectoryIterator::operator==(const DirectoryIterator & iterator) const
{
return name() == iterator.name();
}
inline bool DirectoryIterator::operator!=(const DirectoryIterator & iterator) const
{
return name() != iterator... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>rsiveDirectoryIteratorStrategy_INCLUDED
<|fim_prefix|>//
// RecursiveDirectoryIteratorStategies.h
//
// Library: Foundation
// Package: Filesystem
// Module: RecursiveDirectoryIterator
//
// Definitions of the RecursiveDirectoryIterator strategy classes.
//
// Copyright (c) 2012, Applied Informatics Soft... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// DirectoryIterator_UNIX.h
//
// Library: Foundation
// Package: Filesystem
// Module: DirectoryIterator
//
// Definition of the DirectoryIteratorImpl class for UNIX.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> }
void convert(Poco::LocalDateTime &) const { throw BadCastException("Pair -> Poco::LocalDateTime"); }
void convert(Poco::Timestamp &) const { throw BadCastException("Pair -> Poco::Timestamp"); }
VarHolder * clone(Placeholder<VarHolder> * pVarHolder = 0) const { return cloneHol... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Struct.h
//
// Library: Foundation
// Package: Dynamic
// Module: Struct
//
// Definition of the Struct class.
//
// Copyright (c) 2007, Applied Informatics Software <|fim_suffix|>tException("Cannot cast Struct type to float"); }
void convert(double &) const { throw BadCastException("Canno... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Var.h
//
// Library: Foundation
// Package: Dynamic
// Module: Var
//
// Definition of the Var class.
//
// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Var_INCLUDED
#define Foundation_Var_INCL... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>}
#endif
void convert(bool & val) const
{
val = (_val != 0);
}
void convert(float & val) const
{
val = static_cast<float>(_val);
}
void convert(double & val) const
{
val = static_cast<double>(_val);
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>rator
{
s1.swap(s2);
}
}
#endif // Foundation_VarIterator_INCLUDED
<|fim_prefix|>//
// VarIterator.h
//
// Library: Foundation
// Package: Dynamic
// Module: VarIterator
//
// Definition of the VarIterator class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contri... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>INCLUDED
<|fim_prefix|>//
// DynamicAny.h
//
// Library: Foundation
// Package: Dynamic
// Module: Var
//
// Forward header for Var class to maintain backward compatibility.
//
// Copyright<|fim_middle|> (c) 2007, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Iden... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>// Foundation_DynamicAnyHolder_INCLUDED
<|fim_prefix|>//
// DynamicAnyHolder.h
//
// Library: Foundation
// Package: Dynamic
// Module: VarHolder
//
// Forward header for Va<|fim_middle|>rHolder class to maintain backward compatibility
//
// Copyright (c) 2007, Applied Informatics Software Engineering Gm... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// DynamicFactory.h
//
// Library: Foundation
// Package: Core
// Module: DynamicFactory
//
// Definition of the DynamicFactory class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Dynam... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>e "Poco/Dynamic/Struct.h"
#endif // Foundation_DynamicStruct_INCLUDED
<|fim_prefix|>//
// DynamicStruct.h
//
// Library: Foundation
// Package: Dynamic
// Module: Struct
//
// Forward header for Struct class to maintain backward compatibil<|fim_middle|>ity.
//
// Copyright (c) 2007, Applied Informatics... | fim | ClickHouse/ClickHouse | c |
//
// Environment.h
//
// Library: Foundation
// Package: Core
// Module: Environment
//
// Definition of the Environment class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Environment_INCLUDED
#define... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tImpl();
private:
typedef std::map<std::string, std::string> StringMap;
static StringMap _map;
static FastMutex _mutex;
};
} // namespace Poco
#endif // Foundation_Environment_UNIX_INCLUDED
<|fim_prefix|>//
// Environment_UNIX.h
//
// Library: Foundation
// Package: Core
// Module: Envi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Error.h
//
// Library: Foundation
// Package: Core
// Module: Error
//
// Definition of the Error class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Error_INCLUDED
#define Foundatio... | fim | ClickHouse/ClickHouse | c |
//
// ErrorHandler.h
//
// Library: Foundation
// Package: Threading
// Module: ErrorHandler
//
// Definition of the ErrorHandler class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_ErrorHandler_INCLUDE... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>Event &);
};
//
// inlines
//
inline void Event::set()
{
setImpl();
}
inline void Event::wait()
{
waitImpl();
}
inline void Event::wait(long milliseconds)
{
if (!waitImpl(milliseconds))
throw TimeoutException();
}
inline bool Event::tryWait(long milliseconds)
{
return waitI... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ments
/// but with the arguments being a template parameter this is not
/// necessary.
{
public:
EventArgs();
virtual ~EventArgs();
};
} // namespace Poco
#endif
<|fim_prefix|>//
// EventArgs.h
//
// Library: Foundation
// Package: Events
// Module: EventArgs
//
// Definition of EventArgs.
/... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>can be used to hook custom log message processing into
/// the logging framework.
{
public:
Poco::BasicEvent<const Message> messageLogged;
/// Fired when a message is logged by calling the log() method.
EventChannel();
/// Creates the EventChannel.
void log(const Message & msg);
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ption("cannot signal event (lock)");
_state = true;
if (pthread_cond_broadcast(&_cond))
{
pthread_mutex_unlock(&_mutex);
throw SystemException("cannot signal event");
}
pthread_mutex_unlock(&_mutex);
}
inline void EventImpl::resetImpl()
{
if (pthread_mutex_lock(&_... | fim | ClickHouse/ClickHouse | c |
//
// Exception.h
//
// Library: Foundation
// Package: Core
// Module: Exception
//
// Definition of various Poco exception classes.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Exception_INCLUDED
#def... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// ExpirationDecorator.h
//
// Library: Foundation
// Package: Events
// Module: ExpirationDecorator
//
// Implementation of the ExpirationDecorator template.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifnd... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Expire.h
//
// Library: Foundation
// Package: Events
// Module: Expire
//
// Implementation of the Expire template.
//
// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Expire_INCLUDED
#def... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// ExpireCache.h
//
// Library: Foundation
// Package: Cache
// Module: ExpireCache
//
// Definition of the ExpireCache class.
//
// Copyright (c) 2006, Appli<|fim_suffix|>ue, ExpireStrategy<TKey, TValue>, TMutex, TEventMutex>
/// An ExpireCache caches entries for a fixed time period (per default 10 m... | fim | ClickHouse/ClickHouse | c |
//
// ExpireLRUCache.h
//
// Library: Foundation
// Package: Cache
// Module: ExpireLRUCache
//
// Definition of the ExpireLRUCache class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_ExpireLRUCache_INCLUDED... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>yIndex; /// Maps time to key value
};
} // namespace Poco
#endif // Foundation_ExpireStrategy_INCLUDED
<|fim_prefix|>//
// ExpireStrategy.h
//
<|fim_middle|>// Library: Foundation
// Package: Cache
// Module: ExpireStrategy
//
// Definition of the ExpireStrategy class.
//
// Copyright (c) 2006, Appli... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// FIFOBuffer.h
//
// Library: Foundation
// Package: Core
// Module: FIFOBuffer
//
// Definition of the FIFOBuffer class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_FIFOBuffer_INCLUDED
#d... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// FIFOBufferStream.h
//
// Library: Foundation
// Package: Streams
// Module: FIFOBufferStream
//
// Definition of the FIFOBufferStream class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundat... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> public AbstractEvent<TArgs, FIFOStrategy<TArgs, AbstractDelegate<TArgs>>, AbstractDelegate<TArgs>, TMutex>
/// A FIFOEvent uses internally a FIFOStrategy which guarantees
/// that delegates are invoked in the order they were added to
/// the event.
///
/// Note that as of release 1.4.2, this is the defau... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// FIFOStrategy.h
//
// Library: Foundation
// Package: Events
// Module: FIFOStragegy
//
// Implementation of the FIFOStrategy template.
//
// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_FI... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// FPEnvironment.h
//
// Library: Foundation
// Package: Core
// Module: FPEnvironment
//
// Definitions of class FPEnvironment.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_FPEnvironme... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>g double value)
{
return std::isinf((double)value) != 0;
}
inline bool FPEnvironmentImpl::isNaNImpl(float value)
{
return std::isnan(value) != 0;
}
inline bool FPEnvironmentImpl::isNaNImpl(double value)
{
return std::isnan(value) != 0;
}
inline bool FPEnvironmentImpl::isNaNImpl(long doub... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// FPEnvironment_SU<|fim_suffix|> isInfiniteImpl(double value);
static bool isInfiniteImpl(long double value);
static bool isNaNImpl(float value);
static bool isNaNImpl(double value);
static bool isNaNImpl(long double value);
static float copySignImpl(float target, float source);
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// File.h
//
// Library: Foundation
// Package: Filesystem
// Module: File
//
// Definition of the File class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_File_INCLUDED
#define Foundat... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// FileChannel.h
//
// Library: Foundation
// Package: Logging
// Module: FileChannel
//
// Definition of the FileChannel class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_FileChannel... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// FileStream.h
//
// Library: Foundation
// Package: Streams
// Module: FileStream
//
// Definition of the FileStreamBuf, FileInputStream and FileOutputStream classes.
//
// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>reates and opens a file stream in binary mode for the given URI.
/// The URI must be either a file URI or a relative URI reference
/// containing a path to a local file.
///
/// Throws an FileNotFound exception if the file cannot
/// be opened.
std::istream * open(const Path & pat... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> * buffer, std::streamsize length);
int writeToDevice(const char * buffer, std::streamsize length);
private:
std::string _path;
int _fd;
std::streamoff _pos;
};
} // namespace Poco
#endif // Foundation_FileStream_WIN32_INCLUDED
<|fim_prefix|>//
// FileStream_POSIX.h
//
// Library: Fou... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>mpl() const;
FileSizeImpl usableSpaceImpl() const;
FileSizeImpl freeSpaceImpl() const;
static void handleLastErrorImpl(const std::string & path);
private:
std::string _path;
friend class DirectoryIteratorImpl;
friend class LinuxDirectoryWatcherStrategy;
friend class BSDDirect... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Format.h
//
// Library: Foundation
// Package: Core
// Module: Format
//
// Definition of the format freestanding function.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Format_INCLUDED
#d... | fim | ClickHouse/ClickHouse | c |
//
// Formatter.h
//
// Library: Foundation
// Package: Logging
// Module: Formatter
//
// Definition of the Formatter class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Formatter_INCLUDED
#define Foun... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// FormattingChannel.h
//
// Library: Foundation
// Package: Logging
// Module: Formatter
//
// Definition of the FormattingChannel class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_F... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Foundation.h
//
// Library: Foundation
// Package: Core
// Module: Foundation
//
// Basic definitions for the POCO Foundation library.
// This file must be the first file included by every other Foundation
// header file.
//
// Copyright (c) 2004-2010, Applied Informatics Software Engineering GmbH.... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// FunctionDelegate.h
//
// Library: Foundation
// Package: Events
// Module: FunctionDelegate
//
// Implementation of the FunctionDelegate template.
//
// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef F... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>FunctionPriorityDelegate * pOtherDelegate = dynamic_cast<const FunctionPriorityDelegate *>(other.unwrap());
return pOtherDelegate && this->priority() == pOtherDelegate->priority() && _function == pOtherDelegate->_function;
}
AbstractDelegate<void> * clone() const { return new FunctionPrio... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Glob.h
//
// Library: Foundation
// Package: Filesystem
// Module: Glob
//
// Definition of the Glob class.
//
// Copyright (c) 2004-2009, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Glob_INCLUDED
#define Foundat... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// HMACEngine.h
//
// Library: Foundation
// Package: Crypt
// Module: HMACEngine
//
// Definition of the HMACEngine class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-Li<|fim_suffix|>ngth); }
private:
HMACEngine();
HMACEngine(... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Hash.h
//
// Library: Foundation
// Package: Hashing
// Module: Hash
//
// Definition of the Hash class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Hash_INCLUDED
#define Foundation_Hash... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// HashFunction.h
//
// Library: Foundation
// Package: Hashing
// Module: HashFunction
//
// Definition of the HashFunction class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_HashFunction_... | fim | ClickHouse/ClickHouse | c |
//
// HashMap.h
//
// Library: Foundation
// Package: Hashing
// Module: HashMap
//
// Definition of the HashMap class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_HashMap_INCLUDED
#define Foundation_HashMa... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// HashStatistic.h
//
// Library: Foundation
// Package: Hashing
// Module: HashStatistic
//
// Definition of the HashStatistic class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_HashStatis... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>der(std::istream & istr);
~HexBinaryDecoder();
};
} // namespace Poco
#endif // Foundation_HexBinaryDecoder_INCLUDED
<|fim_prefix|>//
// HexBinaryDecoder.h
//
// Library: Foundation
// Package: Streams
// Module: HexBinary
//
// Definition of the HexBinaryDecoder class.
//
// Copyright (c) 2004-2... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// HexBinaryEncoder.h
//
// Library: Foundation
// Package: Streams
// Module: HexBinary
//
// Definition of the HexBinaryEncoder class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Hex... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>///
/// Please refer to the zlib documentation of inflateInit2() for a description
/// of the windowBits parameter.
~InflatingInputStream();
/// Destroys the InflatingInputStream.
void reset();
/// Resets the zlib machinery so that another zlib stream can be read from
/// the... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// Instantiator.h
//
// Library: Foundation
// Package: Core
// Module: Instantiator
//
// Definition of the Instantiator class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Instantiato... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// JSONString.h
//
// Library: Foundation
// Package: Core
// Module: String
//
// JSONString utility functions.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_JSONString_INCLUDED
#define... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// KeyValueArgs.h
//
// Library: Foundation
// Package: Cache
// Module: KeyValueArgs
//
// Definition of the KeyValueArgs class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_KeyValueArgs_IN... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>AbstractCache<TKey, TValue, LRUStrategy<TKey, TValue>, TMutex, TEventMutex>(LRUStrategy<TKey, TValue>(size))
{
}
~LRUCache() { }
private:
LRUCache(const LRUCache & aCache);
LRUCache & operator=(const LRUCache & aCache);
};
} // namespace Poco
#endif // Foundation_LRUCache_INCLUDE... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// LRUStrategy.h
//
// Library: Foundation
// Package: Cach<|fim_suffix|>();
}
void onIsValid(const void *, ValidArgs<TKey> & args)
{
if (_keyIndex.find(args.key()) == _keyIndex.end())
{
args.invalidate();
}
}
void onReplace(const void *, std::s... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ne sequence.
{
public:
InputLineEndingConverter(std::istream & istr);
/// Creates the LineEndingConverterInputStream and connects it
/// to the given input stream.
InputLineEndingConverter(std::istream & istr, const std::string & newLineCharacters);
/// Creates the LineEndingConverter... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ap(_buckIt, it._buckIt);
swap(_initialized, it._initialized);
}
else
{
_vecIt = it._vecIt;
_endIt = it._endIt;
_buckIt = it._buckIt;
_initialized = it._initialized;
}
}
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> return itInsert->second;
}
}
private:
template <typename T1, typename T2>
bool isEqual(T1 val1, T2 val2) const
{
return val1 == val2;
}
bool isEqual(const std::string & s1, const std::string & s2) const
{
if (!CaseSensitive)
return ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// LocalDateTime.h
//
// Library: Foundation
// Package: DateTime
// Module: LocalDateTime
//
// Definition of the LocalDateTime class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Loca... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>//
// LogFile.h
//
// Library: Foundation
// Package: Logging
// Module: LogFile
//
// Definition of the LogFile class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_LogFile_INCLUDED
#defin... | fim | ClickHouse/ClickHouse | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.