text:
#ifndef DDS_STREAMS_SUB_DETAIL_STREAMDATAREADER_HPP_
#define DDS_STREAMS_SUB_DETAIL_STREAMDATAREADER_HPP_

/**
 * @file
 */

#include <dds/dds.hpp>
#include <dds/streams/sub/qos/StreamDataReaderQos.hpp>
#include <dds/streams/sub/StreamLoanedSamples.hpp>
#include <org/opensplice/streams/topic/TopicTraits.hpp>
#include <org/opensplice/streams/core/policy/DefaultQos.hpp>
#include <map>
#include <sstream>

namespace dds
{
namespace streams
{
namespace sub
{
namespace functors
{
namespace detail
{
    class MaxSamplesManipulatorFunctor
    {
    public:
        MaxSamplesManipulatorFunctor(uint32_t n) :
        n_(n)
        {
        }

        template<typename S>
        void operator()(S& s)
        {
            s.max_samples(n_);
        }
    private:
        uint32_t n_;
    };

    class TimeoutManipulatorFunctor
    {
    public:
        TimeoutManipulatorFunctor(const dds::core::Duration& timeout) :
        timeout_(timeout)
        {
        }

        template<typename S>
        void operator()(S& s)
        {
            s.timeout(timeout_);
        }
    private:
        dds::core::Duration timeout_;
    };

    template <typename T>
    class FilterManipulatorFunctor
    {
    public:
        FilterManipulatorFunctor(bool (*filter_func)(T)) :
        filter_func_(filter_func)
        {
        }

        template<typename S>
        void operator()(S& s)
        {
            s.filter(filter_func_);
        }
    private:
        bool (*filter_func_)(T);
    };
}
}
}
}
}

namespace dds
{
namespace streams
{
namespace sub
{
namespace detail
{

template <typename T>
class StreamDataReader : public org::opensplice::core::EntityDelegate
{
public:
    typedef typename org::opensplice::streams::topic::stream_topic<T>::type StreamT;

    StreamDataReader(const std::string& stream_name,
                     const dds::streams::sub::qos::StreamDataReaderQos& qos) :
                     stream_id_(1), qos_(qos), dp_(org::opensplice::domain::default_id()), sub_(dp_), topic_(dds::core::null)
    {
        init(stream_name);
    }

    StreamDataReader(uint32_t domain_id, const std::string& stream_name,
                    const dds::streams::sub::qos::StreamDataReaderQos& qos) :
                    stream_id_(1), qos_(qos), dp_(domain_id), sub_(dp_), topic_(dds::core::null)
    {
        init(stream_name);
    }

    StreamDataReader(const dds::sub::Subscriber& subscriber, const std::string& stream_name,
                     const dds::streams::sub::qos::StreamDataReaderQos& qos) :
                     stream_id_(1), qos_(qos), dp_(subscriber.participant()), sub_(subscriber), topic_(dds::core::null)
    {
        init(stream_name);
    }

    void init(const std::string& stream_name)
    {
        dds::topic::qos::TopicQos topic_qos = org::opensplice::streams::core::policy::default_topic_qos();
        topic_ = dds::topic::Topic<StreamT>(dp_, stream_name, topic_qos, NULL, dds::core::status::StatusMask::none());

        dds::sub::qos::DataReaderQos dr_qos = org::opensplice::streams::core::policy::default_datareader_qos();
        DDS::DataReader_var r = sub_->sub_->create_datareader(topic_->t_,
                                                              org::opensplice::sub::qos::convertQos(dr_qos),
                                                              NULL,
                                                              0);

        if(r.in() == 0) throw dds::core::NullReferenceError(org::opensplice::core::exception_helper(
            OSPL_CONTEXT_LITERAL(
                "dds::core::NullReferenceError : Unable to create DataReader. "
                "Nil return from ::create_datareader")));

        raw_reader_ = org::opensplice::topic::topic_data_reader<StreamT>::type::_narrow(r.in());
        reader_ = org::opensplice::core::DDS_DR_REF(raw_reader_, org::opensplice::core::DRDeleter(sub_->sub_));
        entity_ = DDS::Entity::_narrow(raw_reader_);

        stream(0);
    }

    class Selector
    {
    public:
        Selector(StreamDataReader<T>* sdr) :
            sdr_(sdr), max_samples_(dds::core::LENGTH_UNLIMITED), timeout_(dds::core::Duration::zero()),
            filter_func_(0)
        {
        }

        Selector& max_samples(uint32_t max_samples)
        {
            max_samples_ = max_samples;
            return *this;
        }

        Selector& timeout(const dds::core::Duration& timeout)
        {
            timeout_ = timeout;
            return *this;
        }

        Selector& filter(bool (*filter_func)(T))
        {
            filter_func_ = filter_func;
            return *this;
        }

        dds::streams::sub::StreamLoanedSamples<T> get()
        {
            return sdr_->get(sdr_->stream(), max_samples_, timeout_, filter_func_);
        }

        template<typename SamplesFWIterator>
        uint32_t get(SamplesFWIterator samples, uint32_t max_samples)
        {
            dds::streams::sub::StreamLoanedSamples<T> sls = sdr_->get(sdr_->stream(), max_samples, timeout_, filter_func_);

            for(uint32_t i = 0; i < sls.length(); i++)
            {
                samples->delegate().data((sls.begin() + i)->data());
                samples++;
            }

            return 0;
        }

        template<typename SamplesBIIterator>
        uint32_t get(SamplesBIIterator samples)
        {
            dds::streams::sub::StreamLoanedSamples<T> sls = sdr_->get(sdr_->stream(), max_samples_, timeout_, filter_func_);

            dds::streams::sub::StreamSample<T> sample;
            for(uint32_t i = 0; i < sls.length(); i++)
            {
                sample.data((sls.begin() + i)->data());
                *samples = sample;
                samples++;
            }

            return sls.length();
        }

        friend class StreamDataReader;
        StreamDataReader<T>* sdr_;
        uint32_t max_samples_;
        dds::core::Duration timeout_;
        bool (*filter_func_)(T);
    };

    class ManipulatorSelector: public Selector
    {
    public:

        ManipulatorSelector(StreamDataReader<T>* sdr) : Selector(sdr)
        {
        }

        ManipulatorSelector& operator >>(dds::streams::sub::StreamLoanedSamples<T>& samples)
        {
            samples = this->Selector::get();
            return *this;
        }
    };

    void stream(uint32_t id)
    {
        if(stream_id_ != id)
        {
            stream_id_ = id;
            stream_ = &streams_[id];
            stream_->id = stream_id_;
            if(!stream_->sls.delegate()->data_info_)
            {
                DDS::StringSeq query_str;
                query_str.length(1);
                std::stringstream ss;
                ss << id;
                query_str[0] = ss.str().c_str();
                stream_->raw_reader_ = raw_reader_;
                DDS::QueryCondition_var query_cond = reader_->create_querycondition(DDS::ANY_SAMPLE_STATE,
                                                                                DDS::ANY_VIEW_STATE,
                                                                                DDS::ANY_INSTANCE_STATE,
                                                                                "id=%0", query_str);
                stream_->wait_set = new DDS::WaitSet();
                stream_->handle = DDS::HANDLE_NIL;
                DDS::ReturnCode_t result = stream_->wait_set->attach_condition(query_cond.in());
                org::opensplice::core::check_and_throw(result, OSPL_CONTEXT_LITERAL("Calling ::attach_condition"));
            }
        }
    }

    uint32_t stream()
    {
        return stream_id_;
    }

    dds::streams::sub::StreamLoanedSamples<T> get()
    {
        return get(stream_id_, dds::core::LENGTH_UNLIMITED, dds::core::Duration::zero(), 0);
    }

    dds::streams::sub::StreamLoanedSamples<T> get(uint32_t stream_id, uint32_t max_samples,
                                                  const dds::core::Duration& timeout, bool (*filter_func)(T))
    {
        stream(stream_id);

        dds::streams::sub::StreamLoanedSamples<T> sls;
        sls.delegate()->reader_ = reader_;
        //If the stream was not found or the stream was found but stream has already been fully read
        if(!stream_->sls.delegate()->data_info_ || stream_->index >= stream_->sls.delegate()->data_info_.get()->data_.get_buffer()[0].buffer.length())
        {
            //Reset the stream index
            stream_->index = 0;

            typename dds::streams::sub::detail::StreamLoanedSamples<T>::data_info_t* data_info =
                new typename dds::streams::sub::detail::StreamLoanedSamples<T>::data_info_t;

            DDS::Duration_t dds_timeout;
            dds_timeout.sec = (DDS::Long)timeout.sec();
            dds_timeout.nanosec = (DDS::Long)timeout.nanosec();
            DDS::ConditionSeq cseq;
            DDS::ReturnCode_t result;
            //Look up the instance handle for the stream if this has not already been done
            if(stream_->handle == DDS::HANDLE_NIL)
            {
                result = stream_->wait_set->wait(cseq, dds_timeout);
                org::opensplice::core::check_and_throw(result, OSPL_CONTEXT_LITERAL("Calling ::wait"));
                StreamT sample;
                sample.id = stream_id;
                stream_->handle = raw_reader_->lookup_instance(sample);
                //Take data
                result = raw_reader_->take_instance(data_info->data_, data_info->info_, 1, stream_->handle,
                                                                      DDS::ANY_SAMPLE_STATE, DDS::ANY_VIEW_STATE, DDS::ANY_INSTANCE_STATE);
                org::opensplice::core::check_and_throw(result, OSPL_CONTEXT_LITERAL("Calling ::take_instance"));
                sls.delegate()->data_info_.reset(data_info);
                stream_->sls = sls;
            }
            else
            {
                //Try to take data
                result = raw_reader_->take_instance(data_info->data_, data_info->info_, 1, stream_->handle,
                                                                                DDS::ANY_SAMPLE_STATE, DDS::ANY_VIEW_STATE, DDS::ANY_INSTANCE_STATE);
                //Wait for data if none was read
                if(result == DDS::RETCODE_NO_DATA)
                {
                    result = stream_->wait_set->wait(cseq, dds_timeout);
                    org::opensplice::core::check_and_throw(result, OSPL_CONTEXT_LITERAL("Calling ::wait"));

                    //Take data once available
                    result = raw_reader_->take_instance(data_info->data_, data_info->info_, 1, stream_->handle,
                                                        DDS::ANY_SAMPLE_STATE, DDS::ANY_VIEW_STATE, DDS::ANY_INSTANCE_STATE);
                }
                else if(result == DDS::RETCODE_ALREADY_DELETED)
                {
                    //If instance has been deleted lookup again on next get
                    stream_->handle = DDS::HANDLE_NIL;
                }
                else
                {
                    org::opensplice::core::check_and_throw(result, OSPL_CONTEXT_LITERAL("Calling ::take_instance"));
                }

                sls.delegate()->data_info_.reset(data_info);
                stream_->sls = sls;

                if(data_info->data_.length() == 0)
                {
                    return sls;
                }
            }
        }
        sls.delegate()->data_info_ = stream_->sls.delegate()->data_info_;

        //Resize the StreamLoanedSamples internal sample vector
        std::size_t size = stream_->sls.delegate()->data_info_.get()->data_.get_buffer()[0].buffer.length() - stream_->index < max_samples ?
            stream_->sls.delegate()->data_info_.get()->data_.get_buffer()[0].buffer.length() - stream_->index : max_samples;
        sls.delegate()->resize(size);
        sls.delegate()->stream(stream_id);

        //Iterate through StreamLoanedSamples placing samples in it
        uint32_t filter_hits = 0;
        typename dds::streams::sub::detail::StreamLoanedSamples<T>::iterator it = sls.delegate()->mbegin();
        typename dds::streams::sub::detail::StreamLoanedSamples<T>::const_iterator itend = sls.end();
        for(;it != itend && stream_->index != size; stream_->index++)
        {
            //If a filter function was not supplied or the filter function evaluates to true
            if(filter_func == 0 || filter_func(stream_->sls.delegate()->data_info_.get()->data_.get_buffer()[0].buffer[stream_->index]))
            {
                //Copy the pointer to the sample data into the StreamSharedSamples
                it->delegate().data(dynamic_cast<T*>(&stream_->sls.delegate()->data_info_.get()->data_.get_buffer()[0].buffer[stream_->index]));
                filter_hits++;
                it++;
            }
        }

        //If the filter has resulted in fewer samples being returned than expected
        if(filter_hits < size)
        {
            //Reduce the size of the StreamLoanedSamples
            sls.delegate()->resize(filter_hits);
        }

        return sls;
    }

    template<typename SamplesFWIterator>
    uint32_t get(SamplesFWIterator samples, uint32_t max_samples)
    {
        dds::streams::sub::StreamLoanedSamples<T> sls = get(stream_id_, max_samples, dds::core::Duration::zero(), 0);

        for(uint32_t i = 0; i < sls.length(); i++)
        {
            samples->delegate().data((sls.begin() + i)->data());
            samples++;
        }

        return 0;
    }

    template<typename SamplesBIIterator>
    uint32_t get(SamplesBIIterator samples)
    {
        dds::streams::sub::StreamLoanedSamples<T> sls = get(stream_id_, dds::core::LENGTH_UNLIMITED, dds::core::Duration::zero(), 0);

        dds::streams::sub::StreamSample<T> sample;
        for(uint32_t i = 0; i < sls.length(); i++)
        {
            sample.data((sls.begin() + i)->data());
            *samples = sample;
            samples++;
        }

        return sls.length();
    }

    const dds::streams::sub::qos::StreamDataReaderQos& qos() const
    {
        return qos_;
    }

    void qos(const dds::streams::sub::qos::StreamDataReaderQos& qos)
    {
        qos_ = qos;
    }

private:
    uint32_t stream_id_;
    dds::streams::sub::qos::StreamDataReaderQos qos_;
    dds::domain::DomainParticipant dp_;
    dds::sub::Subscriber sub_;
    dds::topic::Topic<StreamT> topic_;
    org::opensplice::core::DDS_DR_REF reader_;
    typename org::opensplice::topic::topic_data_reader<StreamT>::type* raw_reader_;
    class stream_t
    {
    public:
        uint32_t id;
        std::size_t index;
        DDS::WaitSet_var wait_set;
        DDS::InstanceHandle_t handle;
        dds::streams::sub::StreamLoanedSamples<T> sls;
        typename org::opensplice::topic::topic_data_reader<StreamT>::type* raw_reader_;

        ~stream_t()
        {
            if(wait_set)
            {
                DDS::ConditionSeq cseq;
                DDS::ReturnCode_t result = wait_set->get_conditions(cseq);
                org::opensplice::core::check_and_throw(result, OSPL_CONTEXT_LITERAL("Calling ::get_conditions"));
                result = wait_set->detach_condition(cseq[0]);
                org::opensplice::core::check_and_throw(result, OSPL_CONTEXT_LITERAL("Calling ::detach_condition"));
                result = raw_reader_->delete_readcondition(dynamic_cast<DDS::ReadCondition*>(cseq[0].in()));
                org::opensplice::core::check_and_throw(result, OSPL_CONTEXT_LITERAL("Calling ::delete_readcondition"));
            }
        }
    };
    std::map<uint32_t, stream_t> streams_;
    stream_t* stream_;
};

}
}
}
}

#endif /* DDS_STREAMS_SUB_DETAIL_STREAMDATAREADER_HPP_ */


text:
module DataDestination::Type
  extend ActiveSupport::Concern

  include ModelAttributes::Type
  include ModelAttributes::Settings
  include DataDestination::Type::HasMessenger

  # Whitelist of demodulized names of data destination classes
  TYPE_CLASS_NAMES = %w[Gmail].freeze

  class_methods do
    def type_class_names
      TYPE_CLASS_NAMES.map { |name| "DataDestinations::#{name}" }
    end
  end
end

redpajama_set_name: RedPajamaGithub


text:
using Community.VisualStudio.Toolkit;
using Microsoft.VisualStudio.Shell;
using SamirBoulema.TGit.Helpers;
using Task = System.Threading.Tasks.Task;

namespace SamirBoulema.TGit.Commands
{
    [Command(PackageGuids.guidTGitCmdSetString, PackageIds.diffContext)]
    internal sealed class DiffFileCommand : BaseCommand<DiffFileCommand>
    {
        protected override async Task ExecuteAsync(OleMenuCmdEventArgs e)
        {
            await ProcessHelper.RunTortoiseGitFileCommand("diff");
        }
    }
}


text:
@implementation NSUserDefaults (STAdditions)

#pragma mark Account Management Methods

- (NSMutableDictionary *)accountsInfo;
{
	NSMutableDictionary *accountsInfo = [[self dictionaryForKey:@"UserDefaultAccountsInfo"] mutableCopy];

    if (!accountsInfo) {
        accountsInfo = [[NSMutableDictionary alloc] init];
    }

    return [accountsInfo autorelease];
}

- (void)setAccountsInfo:(NSDictionary *)newAccountsInfo;
{
    [self setObject:newAccountsInfo forKey:@"UserDefaultAccountsInfo"];
}

- (NSMutableDictionary *)defaultsForAccountWithName:(NSString *)accountName;
{
    NSMutableDictionary *accountDefaults = [[[self accountsInfo] objectForKey:[accountName lowercaseString]] mutableCopy];
    return [accountDefaults autorelease];
}

- (void)setDefaults:(NSDictionary *)defaults forAccountWithName:(NSString *)accountName;
{
    NSMutableDictionary *accountsInfo = [self accountsInfo];

    if (!accountsInfo) {
        accountsInfo = [[[NSMutableDictionary alloc] init] autorelease];
    }

    [accountsInfo setObject:defaults forKey:[accountName lowercaseString]];
    [self setAccountsInfo:accountsInfo];
}

- (void)removeAccountWithName:(NSString *)accountName;
{
    NSMutableDictionary *accountsInfo = [self accountsInfo];
    [accountsInfo removeObjectForKey:[accountName lowercaseString]];
    [self setAccountsInfo:accountsInfo];
}

- (NSArray *)accountsList;
{
    return [[self accountsInfo] sortedArrayUsingKeyValues];
}

- (BOOL)accountExistsForName:(NSString *)accountName;
{
	NSArray *accounts = [[self accountsInfo] allKeys];

    if (!accountName || accounts.count < 1) return NO;

	NSString *currentAccountName;

	for (currentAccountName in accounts) {
		if ([[accountName lowercaseString] isEqualToString: [currentAccountName lowercaseString]]) {
			return YES;
		}
	}

	return NO;
}

#pragma mark Basic Object Persistence Methods

- (void)setObject:(id)value forKey:(NSString *)defaultKey forAccountWithName:(NSString *)accountName;
{
    if (!accountName.length) {
        return [self setObject:value forKey:defaultKey];
    }

    NSMutableDictionary *accountDefaults = [self defaultsForAccountWithName:accountName];

    if (!accountDefaults) {
        accountDefaults = [[[NSMutableDictionary alloc] init] autorelease];
    }

    if (!value) {
        [accountDefaults removeObjectForKey:defaultKey];
    } else {
        [accountDefaults setObject:value forKey:defaultKey];
    }

    [self setDefaults:accountDefaults forAccountWithName:accountName];
}

- (id)objectForKey:(NSString *)defaultKey forAccountWithName:(NSString *)accountName;
{
    if (!accountName.length) {
        return [self objectForKey:defaultKey];
    }

    id value = [[self defaultsForAccountWithName:accountName] objectForKey:defaultKey];

    if (!value) {
        value = [self objectForKey:defaultKey];
    }

    return value;
}

- (void)removeObjectForKey:(NSString *)defaultKey forAccountWithName:(NSString *)accountName;
{
    if (!accountName.length) {
        [self removeObjectForKey:defaultKey];
    }

    NSMutableDictionary *accountDefaults = [self defaultsForAccountWithName:accountName];
    [accountDefaults removeObjectForKey:defaultKey];
    [self setDefaults:accountDefaults forAccountWithName:accountName];
}

#pragma mark Convenience Primitive Setters

- (void)setBool:(BOOL)value forKey:(NSString *)defaultKey forAccountWithName:(NSString *)accountName;
{
    NSNumber *numberValue = @(value);
    [self setObject:numberValue forKey:defaultKey forAccountWithName:accountName];
}

- (void)setDouble:(double)value forKey:(NSString *)defaultKey forAccountWithName:(NSString *)accountName;
{
    NSNumber *numberValue = @(value);
    [self setObject:numberValue forKey:defaultKey forAccountWithName:accountName];
}

- (void)setFloat:(float)value forKey:(NSString *)defaultKey forAccountWithName:(NSString *)accountName;
{
    NSNumber *numberValue = @(value);
    [self setObject:numberValue forKey:defaultKey forAccountWithName:accountName];
}

- (void)setInteger:(NSInteger)value forKey:(NSString *)defaultKey forAccountWithName:(NSString *)accountName;
{
    NSNumber *numberValue = @(value);
    [self setObject:numberValue forKey:defaultKey forAccountWithName:accountName];
}

#pragma mark Convenience Primitive Getters

- (BOOL)boolForKey:(NSString *)defaultKey forAccountWithName:(NSString *)accountName;
{
    id value = [self objectForKey:defaultKey forAccountWithName:accountName];

    return !(!value || ![value isKindOfClass:[NSNumber class]]) && [(NSNumber *)value boolValue];

}

- (double)doubleForKey:(NSString *)defaultKey forAccountWithName:(NSString *)accountName;
{
    id value = [self objectForKey:defaultKey forAccountWithName:accountName];

    if (!value || ![value isKindOfClass:[NSNumber class]]) {
        return 0.0;
    }

    return [(NSNumber *)value doubleValue];
}

- (float)floatForKey:(NSString *)defaultKey forAccountWithName:(NSString *)accountName;
{
    id value = [self objectForKey:defaultKey forAccountWithName:accountName];

    if (!value || ![value isKindOfClass:[NSNumber class]]) {
        return 0.0F;
    }

    return [(NSNumber *)value floatValue];
}

- (NSInteger)integerForKey:(NSString *)defaultKey forAccountWithName:(NSString *)accountName;
{
    id value = [self objectForKey:defaultKey forAccountWithName:accountName];

    if (!value || ![value isKindOfClass:[NSNumber class]]) {
        return 0;
    }

    return [(NSNumber *)value integerValue];
}

#pragma mark Convenience Object Getters

- (NSDictionary *)dictionaryForKey:(NSString *)defaultKey forAccountWithName:(NSString *)accountName;
{
    id value = [self objectForKey:defaultKey forAccountWithName:accountName];

    if (!value || ![value isKindOfClass:[NSDictionary class]]) {
        return nil;
    }

    return (NSDictionary *)value;
}

- (NSArray *)arrayForKey:(NSString *)defaultKey forAccountWithName:(NSString *)accountName;
{
    id value = [self objectForKey:defaultKey forAccountWithName:accountName];

    if (!value || ![value isKindOfClass:[NSArray class]]) {
        return nil;
    }

    return (NSArray *)value;
}

- (NSData *)dataForKey:(NSString *)defaultKey forAccountWithName:(NSString *)accountName;
{
    id value = [self objectForKey:defaultKey forAccountWithName:accountName];

    if (!value || ![value isKindOfClass:[NSData class]]) {
        return nil;
    }

    return (NSData *)value;
}

@end


text:
using System.Web;
using System.Web.Optimization;

namespace MVc_Assignment2
{
    public class BundleConfig
    {
        // For more information on Bundling, visit http://go.microsoft.com/fwlink/?LinkId=254725
        public static void RegisterBundles(BundleCollection bundles)
        {
            bundles.Add(new ScriptBundle("~/bundles/jquery").Include(
                        "~/Scripts/jquery-{version}.js"));

            bundles.Add(new ScriptBundle("~/bundles/jqueryui").Include(
                        "~/Scripts/jquery-ui-{version}.js"));

            bundles.Add(new ScriptBundle("~/bundles/jqueryval").Include(
                        "~/Scripts/jquery.unobtrusive*",
                        "~/Scripts/jquery.validate*"));

            // Use the development version of Modernizr to develop with and learn from. Then, when you're
            // ready for production, use the build tool at http://modernizr.com to pick only the tests you need.
            bundles.Add(new ScriptBundle("~/bundles/modernizr").Include(
                "~/Scripts/jquery-{version}.js",
                "~/Scripts/jquery-ui-{version}.js",
                "~/Scripts/jquery.unobtrusive*",
                "~/Scripts/jquery.validate*",
                "~/Scripts/modernizr-*",
                "~/Scripts/jquery.payment.js",
                "~/Scripts/bootstrap.js",
                "~/Scripts/site.js"
               ));

            bundles.Add(new StyleBundle("~/Content/css").Include(
                "~/Content/site.css",
                "~/Content/bootstrap.css",
                "~/Content/justified-nav.css"));

            bundles.Add(new StyleBundle("~/Content/themes/base/css").Include(
                        "~/Content/themes/base/jquery.ui.core.css",
                        "~/Content/themes/base/jquery.ui.resizable.css",
                        "~/Content/themes/base/jquery.ui.selectable.css",
                        "~/Content/themes/base/jquery.ui.accordion.css",
                        "~/Content/themes/base/jquery.ui.autocomplete.css",
                        "~/Content/themes/base/jquery.ui.button.css",
                        "~/Content/themes/base/jquery.ui.dialog.css",
                        "~/Content/themes/base/jquery.ui.slider.css",
                        "~/Content/themes/base/jquery.ui.tabs.css",
                        "~/Content/themes/base/jquery.ui.datepicker.css",
                        "~/Content/themes/base/jquery.ui.progressbar.css",
                        "~/Content/themes/base/jquery.ui.theme.css"));
        }
    }
}


text:
namespace segmentation_platform {

// Mock model provider for testing, to be used with TestModelProviderFactory.
class MockModelProvider : public ModelProvider {
 public:
  MockModelProvider(
      optimization_guide::proto::OptimizationTarget segment_id,
      base::RepeatingCallback<void(const ModelProvider::ModelUpdatedCallback&)>
          get_client_callback);
  ~MockModelProvider() override;

  MOCK_METHOD(void,
              ExecuteModelWithInput,
              (const std::vector<float>& input,
               base::OnceCallback<void(const absl::optional<float>&)> callback),
              (override));

  MOCK_METHOD(void,
              InitAndFetchModel,
              (const ModelUpdatedCallback& model_updated_callback),
              (override));

  MOCK_METHOD(bool, ModelAvailable, (), (override));

 private:
  base::RepeatingCallback<void(const ModelProvider::ModelUpdatedCallback&)>
      get_client_callback_;
};

// Test factory for providers, keeps track of model requests, but does not run
// the model callbacks.
class TestModelProviderFactory : public ModelProviderFactory {
 public:
  // List of model requests given to the providers.
  struct Data {
    Data();
    ~Data();

    // Map of targets to model providers, added when provider is created. The
    // list is not cleared when providers are destroyed.
    std::map<optimization_guide::proto::OptimizationTarget, MockModelProvider*>
        model_providers;
    // Map from target to updated callback, recorded when InitAndFetchModel()
    // was called on any provider.
    std::map<optimization_guide::proto::OptimizationTarget,
             ModelProvider::ModelUpdatedCallback>
        model_providers_callbacks;
  };

  // Records requests to `data`. `data` is not owned, and the caller must ensure
  // it is valid when the factory or provider is in use. Note that providers can
  // live longer than factory.
  explicit TestModelProviderFactory(Data* data) : data_(data) {}

  // ModelProviderFactory impl, that keeps track of the created provider and
  // callbacks in |data_|.
  std::unique_ptr<ModelProvider> CreateProvider(
      optimization_guide::proto::OptimizationTarget segment_id) override;

  std::unique_ptr<ModelProvider> CreateDefaultProvider(
      optimization_guide::proto::OptimizationTarget) override;

 private:
  raw_ptr<Data> data_;
};

}  // namespace segmentation_platform

#endif  // COMPONENTS_SEGMENTATION_PLATFORM_INTERNAL_EXECUTION_MOCK_MODEL_PROVIDER_H_


text:
<?php

class BMInterfaceTestAbstract extends PHPUnit_Framework_TestCase {

    /**
     * @var BMInterface
     */
    protected $object;
    protected static $userId1WithoutAutopass;
    protected static $userId2WithoutAutopass;
    protected static $userId3WithAutopass;
    protected static $userId4WithAutopass;
    protected static $userId5WithoutAutoaccept;

    /**
     * Sets up the fixture, for example, opens a network connection.
     * This method is called before a test is executed.
     */
    protected function setUp() {
        if (file_exists('../test/src/database/mysql.test.inc.php')) {
            require_once '../test/src/database/mysql.test.inc.php';
        } else {
            require_once 'test/src/database/mysql.test.inc.php';
        }
        $this->init();
        $this->newuserObject = new BMInterfaceNewuser(TRUE);
    }

    protected function createObject() {
        $this->object = new BMInterface(TRUE);
    }

    /**
     * Tears down the fixture, for example, closes a network connection.
     * This method is called after a test is executed.
     */
    protected function tearDown() {

    }

    protected static function getMethod($name) {
        $class = new ReflectionClass('BMInterface');
        $method = $class->getMethod($name);
        $method->setAccessible(true);
        return $method;
    }

    protected function load_game($gameId) {
        $load_game = self::getMethod('load_game');
        return $load_game->invokeArgs($this->object, array($gameId));
    }

    protected function save_game($game) {
        $save_game = self::getMethod('save_game');
        return $save_game->invokeArgs($this->object, array($game));
    }
}


text:
/**
 * This class is root of flyJenkins.
 * @author agun
 *
 */
package org.flyJenkins.action;

import org.flyJenkins.boot.FlyBootstrap;

import hudson.Extension;
import hudson.model.RootAction;

@Extension
public class FlyRootAction implements RootAction {

	/**
	 * flyJenkins does booting.
	 */
	public FlyRootAction(){

		System.out.println("====> new flyRootAction");

		FlyBootstrap.start();
	}

	public String getDisplayName() {
		return "flyJenkins";
	}

	public String getIconFileName() {
		return "gear.png";
	}

	public String getUrlName() {
		return "flyJenkins";
	}

}


text:
.. _dojo/store/JsonRest:

===================
dojo/store/JsonRest
===================

:Authors: Kris Zyp, Colin Snover
:Project owner: Kris Zyp
:since: V1.6

.. contents ::
    :depth: 3

**dojo/store/JsonRest** is a lightweight object store implementation of an HTTP-based (RFC 2616) client with RESTful
data interaction capabilities. This store implements the :ref:`dojo/store <dojo/store>`.

Introduction
============

``dojo/store/JsonRest`` provides full read, write, and notification capabilities through standards based HTTP/REST
interaction with the server using GET, PUT, POST, and DELETE commands. This data store allows you to communicate with
server side database/persistent data storage using the Dojo Store API with JavaScript and efficiently handles create,
read, update, and delete (CRUD) operations. This can greatly simplify client server communication, interacting can be
done simply using straightforward JavaScript instead of having to build your communication for CRUD actions.

Usage
=====

To utilize the module, require in the module, create a new instance, pointing it at your RESTful service, and then
perform your operations:

.. js ::

  require(["dojo/store/JsonRest"], function(JsonRest){
    var store = new JsonRest({
      target: "/some/resource"
    });

    // Get an object by identity
    store.get(id).then(function(item){
      // item will be the DB item
    });

    // Query for objects with options
    store.query("foo=bar", {
      start: 10,
      count: 10,
      sort: [
        { attribute: "baz", descending: true }
      ]
    }).then(function(results){
      // results should contain up to 10 items, sorted by "baz" in descending fashion
    });

    // Store an object identified by identity
    store.put({
      foo: "bar"
    }, {
      id: 3
    });

    // Remove an object by ID
    store.remove(3);
  });

``dojo/store/JsonRest`` impliments the following standard Store API methods:

================================================  =====================================================================
Method                                            Description
================================================  =====================================================================
get(id)                                           Retrieves an object by its identifier, returning the object.

query(query, *options*)                           Queries the store using the provided query.

                                                  The returned value should be an array or a promise with ``forEach()``
                                                  , ``map()``, ``filter()``, ``reduce()``, ``subscribe()``, and
                                                  optional ``close()`` and ``watch()`` methods, and a ``total``
                                                  property (the ``total`` may be a promise). The ``options`` parameter
                                                  may include the following properties (all are optional):

                                                  * ``start`` - Starting offset

                                                  * ``count`` - Number of objects to return

                                                  * ``sort`` - This is an array of sort definitions, where each
                                                    definition contains an ``attribute`` property indicating which
                                                    property to sort on and a ``descending`` property indicating the
                                                    direction of sort.

                                                    For example: ``[{attribute:"price, descending: true}]``. If the
                                                    sort parameter is omitted, then the natural order of the store may
                                                    be applied if there is a natural order.

put(object, *options*)                            Saves the given object. The (optional) ``options`` argument may be
                                                  an object with the following properties (each of these is optional
                                                  and advisory, stores are not required to implement or respond to
                                                  each property):

                                                  * ``id`` - Indicates the identity of the object if a new object is
                                                    created.

                                                  * ``before`` - If the collection of objects in the store has a
                                                    natural ordering, this indicates that the created or updated
                                                    object should be placed before the object specified by the value
                                                    of this property. A value of null indicates that the object should
                                                    be last.

                                                  * ``parent`` - If the store is hierarchical (with single parenting)
                                                    this property indicates the new parent of the created or updated
                                                    object.

                                                  * ``overwrite`` - If this is provided as a boolean it indicates that
                                                    the object should or should not overwrite an existing object. A
                                                    value of ``true`` indicates that a new object should not be
                                                    created, the operation should update an existing object. A value
                                                    of ``false`` indicates that an existing object should not be
                                                    updated, a new object should be created (which is the same as an
                                                    ``add()`` operation). When this property is not provided, either
                                                    an update or creation is acceptable.

add(object, *options*)                            Create a new object. The (optional) ``options`` argument is defined
                                                  the same as ``put()`` (except ``overwrite`` is assumed to be
                                                  ``false``).

remove(id)                                        Delete the object by ``id``.

getIdentity(object)                               Returns an ``object``'s identity
================================================  =====================================================================

It also has the following properties:

=========== ====== ====================================================================================================
Property    Type   Description
=========== ====== ====================================================================================================
headers     Object Additional headers to pass in all requests to the server. These can be overridden by passing
                   additional headers to calls to the store.
target      String The target base URL to use for all requests to the server. This string will be prepended to the
                   ``id`` to generate the URL (relative or absolute) for requests sent to the server.
idProperty  String Indicates the property to use as the identity property. The values of this property should be
                   unique.
sortParam   String The query parameter to be used for holding sort information. If this is omitted, then the sort
                   information is included in a functional query token to avoid colliding with the set of name/value
                   pairs.
accepts     String Defines the Accept header to use on HTTP requests
=========== ====== ====================================================================================================

Implementing a REST Server
==========================

``dojo/store/JsonRest`` follows `RFC 2616 <http://www.ietf.org/rfc/rfc2616.txt>`_ whenever possible to define the
interaction with the server. It uses an HTTP GET request to retrieve data, a PUT or POST request to change items, a
DELETE request to delete items, and a POST or PUT request to create new items. It is recommended that the server
follow a URL structure for resources as follows::

  /{Table}/{id}

This URL will be used to retrieve items by identity and make modifications (PUT and DELETE). It is also recommended
that a ``/{Table}/`` URL is used to represent the entire collection of items for the store. When a query is performed,
any query string is appended to the target URL to retrieve the results of the query. The store expects the results to
be returned in an array. The store will also POST to that URL to create new items.

Method and RESTful Mapping
--------------------------

With ``dojo/store/JsonRest`` the methods map logically to the appropriate HTTP verbs:

========================= =============================================================================================
Method                    Result
========================= =============================================================================================
``get(id)``               This will trigger a GET request to ``{target}/{id}``.  The service shoud return a JSON
                          object if the id exists or ``404`` if it does not.
``query(query, options)`` This will trigger a GET request to ``{target}?{query}``. If ``query`` is an object, it will
                          be serialized using :ref:`dojo/io-query::objectToQuery() <dojo/io-query#objecttoquery>`. If
                          ``query`` is a string, it is appended to the URL as-is. If ``options`` includes a ``sort``
                          property, it will be serialized as a query parameter as well; see `Sorting`_ for more
                          information.  The service should return a JSON array of objects.  If no matches are found,
                          it should return an empty array.
``remove(id)``            This will trigger a DELETE request to ``{target}/{id}``.  The service should repsond with a
                          ``204`` if successful, a ``404`` if not found or another appropriate HTTP status code.
``put(object, options)``  If object includes an identity property, or ``options`` includes an ``id``, this will
                          trigger a PUT request to ``{target}/{id}`` with the request body being the provided object
                          serialized as JSON. If no identity is provided, then a POST request is made to ``{target}``
                          with the object as the body. If the ``options.incremental`` property is ``true``, then a
                          POST request is made to ``{target}/{id}`` with the object as the body. You may also include
                          an ``options.overwrite`` property. If ``options.overwrite`` is set to ``true``, then an ``If-
                          Match: *`` header is included. If ``options.overwrite`` is set to ``false``, then an ``If-
                          None-Match: *`` header is included.
``add(object, options)``  This behaves exactly like ``put(object, options)``, except that ``options.overwrite`` is set
                          to ``false``, indicating that a new object must be created.
========================= =============================================================================================

Paging
------

The store uses HTTP's ``Range:`` header to perform paging. When a request is made for a range of items, the store will
include a ``Range:`` header with an items range unit specifying the range.  For example::

  Range: items=0-24

On your server, you should look at the header in the request to know which items to return. The server should respond
with a ``Content-Range:`` header to indicate how many items are being returned and how many total items exist.  For
example::

  Content-Range: items 0-24/66

The returned ``total`` is available as a further promise on the returned promise of data which returns the total
number of available rows indicated in the ``Content-Range:`` header as a number, so you can retrieve it like this:

.. js ::

  require(["dojo/store/JsonRest"], function(JsonRest){
    var store = new JsonRest({
      target: "/Table"
    });

    var self = this;

    var results = store.query("foo=bar").then(function(data){
      results.total.then(function(total){
        console.log("total results: ", total);
        console.log("go on and use data ", data, " with this ", self);
      });
    });
  });

Sorting
-------

When a query request is made that includes a ``sort`` option in the ``options`` object, an additional sort field is
added to the query string. If the store's ``sortParam`` property is set, it will use that value as the key for the
field in the query string.

For example, given the following store and request:

.. js ::

  require(["dojo/store/JsonRest"], function(JsonRest){

    var store = new JsonRest({
      target: "/FooObject/",
      sortParam: "sortBy"
    });

    store.query({ foo: "value1" }, {
      sort: [
        { attribute: "foo" },
        { attribute: "bar", descending: true }
      ]
    });
  });

The resulting request to the server would be::

  /FooObject/?foo=value1&sortBy=+foo,-bar

If ``sortParam`` is not set, the sort value is appended without a key-value pair, surrounded by "sort()"::

  /FooObject/?foo=value1&sort(+foo,-bar)

Headers
-------

Starting in Dojo 1.8, it is possible to send headers along with all requests made using the JsonRest store. This can
either be done by setting the ``headers`` property of the store itself, in which case all requests will include the
provided headers, or on a per-call basis by setting the ``headers`` property of the associated ``options`` object for
calls to ``get``, ``add``, ``put``, ``remove``, or ``query``.

If header is provided on the ``options`` object passed to a call, it will override any similarly-named headers given
directly on the store:

.. js ::

  var store = new JsonRestStore({
    target: "/FooObject/",
    headers: { "X-Custom-Header": "Foo" } // All calls to server will include X-Custom-Header: Foo
  });

  store.query({ foo: "value1" }, {
    headers: { "X-Custom-Header": "Bar" } // This call will include X-Custom-Header: Bar instead
  });

Notes
=====

*Note*: ``dojo/store/JsonRest`` does not provide all the functionality of
:ref:`dojox/data/JsonRestStore <dojox/data/JsonRestStore>` itself. Additional modules and layers are used to provide
schema validation, referencing, caching, and other functionality.  See :ref:`dojo/store <dojo/store>` for the other
modules that can be composed with this module to add these features.

See Also
========

* :ref:`dojo/store <dojo/store>` - The Dojo Store API.

* :ref:`dojo/data <dojo/data>` - The legacy Dojo Data Store API.

* :ref:`dojox/data/JsonRestStore <dojox/data/JsonRestStore>` - The deprecated JSON RESTful client store.


text:
<?php

#require_once 'CompleXml/Output/Interface.php';
/**
 * Класс передающий XML в браузер для XSLT преобразования
 */
class CompleXml_Output_Browser implements CompleXml_Output_Interface {

    public static function execute(CompleXml_Controller $ControllerObject) {
        if (!ini_get('browscap')) {
            return false;
        }
        $settings = CompleXml_Config::readComponentSettings(__CLASS__);
        $browsers = (array) $settings['xslt_browsers'];
        if (($settings['with_get_browsers_cache'])&&($ControllerObject->Session->getBool(__CLASS__))) {
            $browser_info = $ControllerObject->Session->getValue(__CLASS__);
        }else {
            $browser_info = get_browser();
            if ($settings['with_get_browsers_cache']) {
                $ControllerObject->Session->setValue(__CLASS__, $browser_info);
            }
        }
        $is_correct = false;
        foreach ($browsers as $name => $version) {

            if ((strpos($browser_info->browser,$name)===0)&&($browser_info->version>=$version)) {
                $is_correct = true;
                break;
            }
        }
        if (!$is_correct) {
            return false;
        }
        $ControllerObject->View->setLocalePath($settings['locales']);
        $file = $settings['templates'].'/'.$ControllerObject->View->getTemplate().'.xsl';

        $xmlString = $ControllerObject->View->getXml();

        if ($ControllerObject->View->hasIncludedXml()) {
            $xml = new DomDocument ( );
            $xml->loadXML ( $xmlString );
            @$xml->xinclude ();
            $outputXml = $xml->saveXML ();
        }else {
            $outputXml = $xmlString;
        }

        $outputXml = str_replace('?>', '?><?xml-stylesheet type="text/xsl" href="'.$file.'"?>', $outputXml);

        header ( "Content-type: text/xml" );
        $ControllerObject->Response->nocache ();
        echo $outputXml;
        return true;
    }
}


text:
import { Component, OnInit } from '@angular/core';

import { AuthService } from '../auth.service';

@Component({
  templateUrl: './signout.component.html'
})
export class SignoutComponent implements OnInit {

  public signoutError = false;
  constructor(
    private authService: AuthService
  ) {}

  public ngOnInit(): void {
    this.authService.signout()
      .subscribe(
        () => this.authService.goToSignin(),
        () => this.signoutError = true
      );
  }
}


text:
# iSlider
*iSlider is expected to be used in mobile terminal.*

`iSlider` simulates the sliding behavior ``in mobile terminal``.It's lightweight but can meet your demand to deal with the touch,scroll,swipe and etc.
Based on iSlider,lots of UI can be implemented.Enjoy~ -_-"
## Basic Usage
1. Refer to the demo:

  ```sh
  $ pwd
  /path/iSlider
  $ npm install
  $ grunt default
  ```
  *demo can be seen in `demo` folder*

2. Get compressed file:

  ```sh
  $ grunt dist
  ```
  *new compressed file can be found in 'dist' folder*

3. Steps to init:

  1. inlude js file to your page

     ```html
     <head>
       <script type="text/javascript" src="../dist/iSlider.min.js"></script>
     </head>
     ```

  2. basic html structure

     ```html
     <div id="your_container" class="container">
        <div class="wrap">your content</div>
     </div>
     ```

 3. basic stylesheet

     ```css
      .container{
        position: relative;
        width: 360px;
        height: 640px;
        overflow: hidden;
      }
      .wrap{
        position: absolute;
        top: 0;
        left: 0;
        width: 100%;
      }
     ```

  4. init an iSlider component

    ```javascript
    var oSlider = new ISlider('#your_container', settings);
    ```

## Deep Dive
### settings:

*after init one iSlider component like:*

```javascript
var oSlider = new ISlider('#your_container', settings);
```
*settings should be a JSON object like `{direction: 'y'}`*

```javascript
var settings = {
    /**
     * value:'x' or 'y', set the direction to slide in the viewport,default is 'y'.
     */
    direction: value
    /**
     * value:true or false, whether to use the default scrolling of the browser in the opposite direction.
     */
    oppositeSlide: value
    /**
     * value:true or false, whether to lock the other direction.
     * only one direction is available for all of the iSlider components.
     * that means if one direction was locked,other iSlider components won't be scrollable in the opposite direction.
     */
    lockTheOtherDirection: value
    /**
     * value:0 or other number, the initial 'x' position of the slider.
     */
    startX: value
    /**
     * value:0 or other number, the initial 'x' position of the slider.
     */
    startY: value
}
```

### apis:

*some api is available after init a oSlider object:*

```javascript
oSlider.goWithTouchStart = function (x, y){
	some code here;
}
```
`goWithTouchStart` will be executed when the touch start event emitted.

`x` and `y` is the position of the slider which will be passed in when executed.

```javascript
oSlider.goWithTouchMove = function (x, y){
	some code here;
}
```
`goWithTouchMove` is like the usage above,but executed when the touch move event emitted.

```javascript
oSlider.goWithTouchEnd = function (x, y, inertia){
	some code here;
}
```
`goWithTouchEnd` is like the usage above,but executed when the touch end event emitted.

additional: the parameter `inertia` is the destination position of the inertia.and if there's no inertia,`null` will be its value.

```javascript
oSlider.moveTo(x, y);
```
move to the specific destination.this's just a 'translate' and no animation.

'x','y' are the destination position.

```javascript
oSlider.animateTo(startPos, rightPos, duration, curve);
```
animate to the specific destination.

`startPos` the start position of this animation.

`rightPos` the destination position.

`duration` the duration is optional(milliseconds),there's a default value.

`curve` the animation curve object is optional,there's a default value.Other value is expected from `Math.tween`.

```javascript
oSlider.resize();
```
'slider' will recalculate the width and height of viewport and if its position is not right it will adjust to get a right position.

```javascript
oSlider.updateRightPosition();
```
adjust the postion of 'slider' to the right one.you know,'slider' may be out of boundary in some situations.

```javascript
oSlider.stopInertia();
```
stop to amend for right position automatically.and stop 'inertia'.that means the slider will stop after touch move and no functions will be executed after touch end fired.

```javascript
oSlider.stopInertia();
```
resume to amend right position automatically.and resume 'inertia' effect.

**only part of the api is detailed here.other can be referred to the notation in source code.**

## License
iSlider is licensed under the MIT license. (http://opensource.org/licenses/MIT)

## Issues
Any issues pls submit in github or contact me by mail(tony7leek@gmail.com).


text:
package cc;

import cc.event.Event;

public final class Computer
{
    static {
        System.load("cc/native/Computer.lua");
    }

    private Computer() {}
    public static native void shutdown();
    public static native void restart();
    public static native void sleep(double s);
    public static native boolean isTurtle();
    public static native int getTime();
    public static native float getClock();
    public static native Event pullEvent();
    public static native Event pullEvent(String filter);
    public static native Event pullEventRaw();
    public static native Event pullEventRaw(String filter);
    public static native void queueEvent(Event e);
    public static native int startTimer(double t);
    public static native int setAlarm(double t);
    public static native String getVersion();
    public static native int getComputerID();
    public static native String getComputerLabel();
    public static native void setComputerLabel(String label);
    public static native String read();
    public static native String read(String rep);
}


text:
package com.box.l10n.mojito.entity;

import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.ForeignKey;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
import org.hibernate.annotations.Type;
import org.joda.time.DateTime;

/** @author jaurambault */
@Entity
@Table(name = "sla_incident")
public class SlaIncident extends AuditableEntity {

  @Column(name = "closed_date")
  @Type(type = "org.jadira.usertype.dateandtime.joda.PersistentDateTime")
  private DateTime closedDate;

  @ManyToMany(fetch = FetchType.EAGER)
  @JoinTable(
      name = "sla_incident_repositories",
      joinColumns = {@JoinColumn(name = "sla_incident_id")},
      inverseJoinColumns = {@JoinColumn(name = "repository_id")},
      foreignKey = @ForeignKey(name = "FK__SLA_INCIDENT_REPOSITORIES__SLA_INCIDENT__ID"),
      inverseForeignKey = @ForeignKey(name = "FK__SLA_INCIDENT_REPOSITORIES__REPOSITORY__ID"))
  private Set<Repository> repositories;

  public Set<Repository> getRepositories() {
    return repositories;
  }

  public void setRepositories(Set<Repository> repositories) {
    this.repositories = repositories;
  }

  public DateTime getClosedDate() {
    return closedDate;
  }

  public void setClosedDate(DateTime closedDate) {
    this.closedDate = closedDate;
  }
}


text:
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using UnityEngine;

namespace Academy.HoloToolkit.Unity
{
    public class Singleton<T> : MonoBehaviour where T : Singleton<T>
    {
        private static T _Instance;

        public static T Instance
        {
            get
            {
                if (_Instance == null)
                {
                    _Instance = FindObjectOfType<T>();
                }
                return _Instance;
            }
        }
    }
}


text:
package org.apache.drill.exec.physical.rowSet.model;

import org.apache.drill.exec.record.MaterializedField;
import org.apache.drill.exec.record.metadata.ColumnMetadata;
import org.apache.drill.exec.record.metadata.TupleMetadata;
import org.apache.drill.exec.record.metadata.TupleSchema;

/**
 * Interface for retrieving and/or creating metadata given
 * a vector.
 */

public interface MetadataProvider {
  ColumnMetadata metadata(int index, MaterializedField field);
  MetadataProvider childProvider(ColumnMetadata colMetadata);
  TupleMetadata tuple();

  public static class VectorDescrip {
    public final MetadataProvider parent;
    public final ColumnMetadata metadata;

    public VectorDescrip(MetadataProvider provider, int index,
        MaterializedField field) {
      parent = provider;
      metadata = provider.metadata(index, field);
    }
  }

  public static class MetadataCreator implements MetadataProvider {

    private final TupleSchema tuple;

    public MetadataCreator() {
      tuple = new TupleSchema();
    }

    public MetadataCreator(TupleSchema tuple) {
      this.tuple = tuple;
    }

    @Override
    public ColumnMetadata metadata(int index, MaterializedField field) {
      return tuple.addView(field);
    }

    @Override
    public MetadataProvider childProvider(ColumnMetadata colMetadata) {
      return new MetadataCreator((TupleSchema) colMetadata.mapSchema());
    }

    @Override
    public TupleMetadata tuple() { return tuple; }
  }

  public static class MetadataRetrieval implements MetadataProvider {

    private final TupleMetadata tuple;

    public MetadataRetrieval(TupleMetadata schema) {
      tuple = schema;
    }

    @Override
    public ColumnMetadata metadata(int index, MaterializedField field) {
      return tuple.metadata(index);
    }

    @Override
    public MetadataProvider childProvider(ColumnMetadata colMetadata) {
      return new MetadataRetrieval((TupleSchema) colMetadata.mapSchema());
    }

    @Override
    public TupleMetadata tuple() { return tuple; }
  }
}


text:
<?php

namespace Symfony\Component\Validator\Constraints;

class Blank extends \Symfony\Component\Validator\Constraint
{
    public $message = 'This value should be blank';
}


text:
/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.facebook.presto.tests.hive;

import com.google.inject.Inject;
import com.teradata.tempto.Requirement;
import com.teradata.tempto.RequirementsProvider;
import com.teradata.tempto.configuration.Configuration;
import com.teradata.tempto.fulfillment.table.MutableTablesState;
import com.teradata.tempto.fulfillment.table.hive.HiveDataSource;
import com.teradata.tempto.fulfillment.table.hive.HiveTableDefinition;
import com.teradata.tempto.query.QueryResult;
import org.testng.annotations.Test;

import java.sql.SQLException;
import java.util.Optional;

import static com.facebook.presto.tests.TestGroups.HIVE_CONNECTOR;
import static com.facebook.presto.tests.TestGroups.QUARANTINE;
import static com.teradata.tempto.Requirements.allOf;
import static com.teradata.tempto.assertions.QueryAssert.Row.row;
import static com.teradata.tempto.assertions.QueryAssert.assertThat;
import static com.teradata.tempto.fulfillment.table.MutableTableRequirement.State.LOADED;
import static com.teradata.tempto.fulfillment.table.TableRequirements.mutableTable;
import static com.teradata.tempto.fulfillment.table.hive.InlineDataSource.createResourceDataSource;
import static com.teradata.tempto.query.QueryExecutor.query;
import static org.assertj.core.api.Assertions.assertThat;

public class TestTablePartitioningSelect
        extends HivePartitioningTest
        implements RequirementsProvider
{
    private static final HiveTableDefinition SINGLE_INT_COLUMN_PARTITIONEND_TEXTFILE = singleIntColumnPartitionedTableDefinition("TEXTFILE", Optional.of("DELIMITED FIELDS TERMINATED BY '|'"));
    private static final HiveTableDefinition SINGLE_INT_COLUMN_PARTITIONED_ORC = singleIntColumnPartitionedTableDefinition("ORC", Optional.empty());
    private static final HiveTableDefinition SINGLE_INT_COLUMN_PARTITIONED_RCFILE = singleIntColumnPartitionedTableDefinition("RCFILE", Optional.of("SERDE 'org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe'"));
    private static final HiveTableDefinition SINGLE_INT_COLUMN_PARTITIONED_PARQUET = singleIntColumnPartitionedTableDefinition("PARQUET", Optional.empty());
    private static final String TABLE_NAME = "test_table";

    @Inject
    private MutableTablesState tablesState;

    private static HiveTableDefinition singleIntColumnPartitionedTableDefinition(String fileFormat, Optional<String> serde)
    {
        String tableName = fileFormat.toLowerCase() + "_single_int_column_partitioned";
        HiveDataSource dataSource = createResourceDataSource(tableName, "" + System.currentTimeMillis(), "com/facebook/presto/tests/hive/data/single_int_column/data." + fileFormat.toLowerCase());
        return HiveTableDefinition.builder(tableName)
                .setCreateTableDDLTemplate(buildSingleIntColumnPartitionedTableDDL(fileFormat, serde))
                .addPartition("part_col = 1", dataSource)
                .addPartition("part_col = 2", dataSource)
                .build();
    }

    private static String buildSingleIntColumnPartitionedTableDDL(String fileFormat, Optional<String> rowFormat)
    {
        StringBuilder sb = new StringBuilder();
        sb.append("CREATE EXTERNAL TABLE %NAME%(");
        sb.append("   col INT");
        sb.append(") ");
        sb.append("PARTITIONED BY (part_col INT) ");
        if (rowFormat.isPresent()) {
            sb.append("ROW FORMAT ").append(rowFormat.get());
        }
        sb.append(" STORED AS " + fileFormat);
        return sb.toString();
    }

    @Override
    public Requirement getRequirements(Configuration configuration)
    {
        return allOf(
                mutableTable(SINGLE_INT_COLUMN_PARTITIONEND_TEXTFILE, TABLE_NAME, LOADED),
                mutableTable(SINGLE_INT_COLUMN_PARTITIONED_ORC, TABLE_NAME, LOADED),
                mutableTable(SINGLE_INT_COLUMN_PARTITIONED_RCFILE, TABLE_NAME, LOADED),
                mutableTable(SINGLE_INT_COLUMN_PARTITIONED_PARQUET, TABLE_NAME, LOADED)
        );
    }

    @Test(groups = {HIVE_CONNECTOR, QUARANTINE})
    public void testSelectPartitionedHiveTableDifferentFormats()
            throws SQLException
    {
        String tableNameInDatabase = tablesState.get(TABLE_NAME).getNameInDatabase();

        String selectFromAllPartitionsSql = "SELECT * FROM " + tableNameInDatabase;
        QueryResult allPartitionsQueryResult = query(selectFromAllPartitionsSql);
        assertThat(allPartitionsQueryResult).containsOnly(row(42, 1), row(42, 2));
        assertProcessedLinesCountEquals(selectFromAllPartitionsSql, allPartitionsQueryResult, 2);

        String selectFromOnePartitionsSql = "SELECT * FROM " + tableNameInDatabase + " WHERE part_col = 2";
        QueryResult onePartitionQueryResult = query(selectFromOnePartitionsSql);
        assertThat(onePartitionQueryResult).containsOnly(row(42, 2));
        assertProcessedLinesCountEquals(selectFromOnePartitionsSql, onePartitionQueryResult, 1);
    }

    private static final long GET_PROCESSED_LINES_COUNT_RETRY_SLEEP = 500;

    private void assertProcessedLinesCountEquals(String sqlStatement, QueryResult allPartitionsQueryResult, int expected)
            throws SQLException
    {
        long processedLinesCountAllPartitions = getProcessedLinesCount(sqlStatement, allPartitionsQueryResult);
        if (processedLinesCountAllPartitions != expected) {
            try {
                Thread.sleep(GET_PROCESSED_LINES_COUNT_RETRY_SLEEP);
            }
            catch (InterruptedException e) {
            }
            processedLinesCountAllPartitions = getProcessedLinesCount(sqlStatement, allPartitionsQueryResult);
        }
        assertThat(processedLinesCountAllPartitions).isEqualTo(expected);
    }
}


text:
	// Assume Vector to be n rows by 1 column
	typedef struct {
		double* data;
		unsigned int length;
	} Vector;

	Vector lb_create_vector(double* data, unsigned int length);
	Vector lb_allocate_vector(unsigned int length);
	void lbdp(Vector a, Vector b, double* result);
	void lbstv(double s, Vector v, Vector result);
	#define LB_VECTOR_INCLUDED
#endif


text:
namespace WebCore {

void B::trace(Visitor* visitor)
{
    // Class is ignored so no checking here.
}

void C::trace(Visitor* visitor)
{
    // Missing trace of m_obj.
    // Ignored base class B does not need tracing.
}

}


text:
from assetsy.env import Environment
from os import path
import mimetypes
# FlaskEnvironment(Environment):
#     def url(self,asset):
from werkzeug.exceptions import NotFound
from zlib import adler32
import os
from time import time

class FlaskEnvironment(Environment):
    def init_app(self, app, base=None):
        self.app = app
        if not base:
            base = get_static_folder(app)
            base = os.path.normpath(base)
        self.base = base
    def url(self,asset):
        return self.app.config.get('ASSETSY_URL',lambda x:'/_assetsy/%s'%x)(asset.path)

class Assetsy():
    cache_timeout = 60 * 60 * 12
    add_etags=True
    def __init__(self, app=None):
        self.app = app
        self.reload_handler = None
        self.env = FlaskEnvironment()
        # if app:
        if app:
            self.init_app(app)

    def _init_processors (self):
        assetsy_processors = self.app.config.get('ASSETSY_PROCESSORS',{})
        for name,processor in assetsy_processors.iteritems():
            self.env.processor_manager[name] = processor

    def serve(self,filename):
        outputs = self.env.outputs or self.env.build()
        try:
            asset = outputs[filename]
            mimetype = mimetypes.guess_type(filename)[0]
            mtime = asset.last_modified
            rv = self.app.response_class(asset.content, mimetype=mimetype,
                                    direct_passthrough=True)
            if mtime is not None:
                rv.last_modified = int(mtime)

            rv.cache_control.public = True
            if self.cache_timeout:
                rv.cache_control.max_age = self.cache_timeout
                rv.expires = int(time() + self.cache_timeout)

            if self.add_etags and filename is not None:
                rv.set_etag('assetsy-%d-%s-%s' % (
                    mtime,
                    len(asset.content),
                    adler32(
                        filename.encode('utf8') if isinstance(filename, unicode)
                        else filename
                    ) & 0xffffffff
                ))
            return rv
        except KeyError:
            raise NotFound()

    def init_app(self, app):
        self.env.init_app(app)
        self._init_processors()
        app.jinja_env.add_extension('assetsy.ext.jinja2.AssetsyExtension')
        app.jinja_env.assetsy_env = self.env
        self.instant_reload = app.config.get('ASSETSY_INSTANT',True)
        if app.debug: app.add_url_rule('/_assetsy/<path:filename>', 'assetsy', self.serve)

    def add(self,*args,**kwargs):
        name = kwargs.pop('name',None)
        asset = self.env.asset(*args,**kwargs)
        return asset

def get_static_folder(app_or_blueprint):
    """Return the static folder of the given Flask app
    instance, or module/blueprint.

    In newer Flask versions this can be customized, in older
    ones (<=0.6) the folder is fixed.
    """
    if hasattr(app_or_blueprint, 'static_folder'):
        return app_or_blueprint.static_folder
    return path.join(app_or_blueprint.root_path, 'static')

try:
    from flaskext import script
except ImportError:
    pass
else:
    class ManageAssetsy(script.Command):
        # option_list = (
        #     script.Option('--force', '-f', dest='force',default=False,type=bool),
        # )

        def __init__(self, app, dir='assetsy',env=None):
            self.app = app
            self.env = env or self.app.jinja_env.assetsy_env
            self.dir = dir if os.path.isabs(dir)\
                else os.path.join(self.app.root_path,dir)
        def run(self,force=False):
            # print force
            self.env.compile(self.dir,bool(force))


text:
// Copyright (c) 2016-2017, ARM Limited or its affiliates. All rights reserved
//
// This file and the related binary are licensed under the ARM Object Code and
// Headers License; you may not use these files except in compliance with this
// license.
//
// You may obtain a copy of the License at <.../external/nrf_cc310/license.txt>
//
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef CRYS_RSA_SCHEMES_H
#define CRYS_RSA_SCHEMES_H

#include "crys_error.h"
#include "crys_rsa_types.h"
#include "crys_rnd.h"

#ifdef __cplusplus
extern "C"
{
#endif

/*!
@file
@brief This module defines APIs that support [PKCS1_1.5] and [PKCS1_2.1] encryption and signature schemes.
*/

/**********************************************************************************************************/
/*!
@brief This function implements the Encrypt algorithm, as defined in [PKCS1_2.1] and [PKCS1_1.5].

It should not be called directly. Instead, use macros ::CRYS_RSA_OAEP_Encrypt or ::CRYS_RSA_PKCS1v15_Encrypt.

@return CRYS_OK on success.
@return A non-zero value from crys_rsa_error.h on failure.
*/
CIMPORT_C CRYSError_t SaSi_RsaSchemesEncrypt(
                        CRYS_RND_Context_t *rndContext_ptr,         /*!< [in/out] Pointer to the RND context buffer. */
                        CRYS_RSAUserPubKey_t  *UserPubKey_ptr,      /*!< [in]  Pointer to the public key data structure. */
                        CRYS_RSAPrimeData_t   *PrimeData_ptr,       /*!< [in]  Pointer to a temporary structure that is internally used as workspace for the
									       Encryption operation. */
                        CRYS_RSA_HASH_OpMode_t hashFunc,            /*!< [in]  The HASH function to be used. One of the supported SHA-x HASH modes, as defined
									       in ::CRYS_RSA_HASH_OpMode_t (MD5 is not supported).*/
                        uint8_t  *L,                                /*!< [in]  The label input pointer. Relevant for [PKCS1_2.1] only. NULL by default.
									       NULL for [PKCS1_1.5]. */
                        uint16_t  Llen,                             /*!< [in]  The label length. Relevant for [PKCS1_2.1] only. Zero by default.
									       Must be <=2048. Zero for [PKCS1_1.5]. */
                        CRYS_PKCS1_MGF_t MGF,                       /*!< [in]  The mask generation function. [PKCS1_2.1] defines MGF1, so the only value
									       allowed here is CRYS_PKCS1_MGF1. */
                        uint8_t   *DataIn_ptr,                      /*!< [in]  Pointer to the data to encrypt. */
                        uint16_t   DataInSize,                      /*!< [in]  The size (in bytes) of the data to encrypt. The data size must be:
                                                                                - For [PKCS1_2.1], DataSize <= modulus size - 2*HashLen - 2.
                                                                                - For [PKCS1_1.5], DataSize <= modulus size - 11. */
                        uint8_t   *Output_ptr,                      /*!< [out] Pointer to the encrypted data. The buffer must be at least modulus size bytes long. */
                        CRYS_PKCS1_version  PKCS1_ver               /*!< [in]  [PKCS1_1.5] or [PKCS1_2.1], according to the functionality required. */
);

/*!
   @brief
   CRYS_RSA_OAEP_PSS21_Encrypt implements the RSAES-OAEP algorithm
   as defined in PKCS#1 v2.1 8.1.

   \note It is not recommended to use hash MD5 in OAEP PKCS1 ver 2.1, therefore
   	it is not supported.

   This function combines the RSA encryption primitive and the
   EME-OAEP encoding method, to provide an RSA-based encryption
   method that is semantically secure against adaptive
   chosen-ciphertext attacks. For additional details, please refer to
   the PKCS#1 standard.
*/
#define CRYS_RSA_OAEP_Encrypt(rndContext_ptr, UserPubKey_ptr,PrimeData_ptr,HashMode,L,Llen,MGF,Data_ptr,DataSize,Output_ptr)\
		SaSi_RsaSchemesEncrypt(rndContext_ptr, UserPubKey_ptr,PrimeData_ptr,HashMode,L,Llen,MGF,Data_ptr,DataSize,Output_ptr,CRYS_PKCS1_VER21)

/*!
   @brief
   CRYS_RSA_PKCS1v15_Encrypt implements the RSAES-PKCS1v15 algorithm
   as defined in PKCS#1 v2.1 8.2.
*/
#define CRYS_RSA_PKCS1v15_Encrypt(rndContext_ptr, UserPubKey_ptr,PrimeData_ptr,DataIn_ptr,DataInSize,Output_ptr)\
		SaSi_RsaSchemesEncrypt(rndContext_ptr, UserPubKey_ptr,PrimeData_ptr,CRYS_RSA_HASH_NO_HASH_mode,NULL,0,CRYS_PKCS1_NO_MGF,DataIn_ptr, \
		DataInSize, Output_ptr,CRYS_PKCS1_VER15)

/**********************************************************************************************************/
/*!
@brief This function implements the Decrypt algorithm, as defined in [PKCS1_2.1] and [PKCS1_1.5].

It should not be called directly. Instead, use macros ::CRYS_RSA_OAEP_Decrypt or ::CRYS_RSA_PKCS1v15_Decrypt.

@return CRYS_OK on success.
@return A non-zero value from crys_rsa_error.h on failure.
*/
CIMPORT_C CRYSError_t SaSi_RsaSchemesDecrypt(
                                CRYS_RSAUserPrivKey_t  *UserPrivKey_ptr,    /*!< [in]  Pointer to the private key data structure of the user. */
                                CRYS_RSAPrimeData_t    *PrimeData_ptr,      /*!< [in]  Pointer to a temporary structure that is internally used as workspace
										       for the decryption operation. */
                                CRYS_RSA_HASH_OpMode_t  hashFunc,           /*!< [in]  The HASH function to be used. One of the supported SHA-x HASH modes,
										       as defined in ::CRYS_RSA_HASH_OpMode_t (MD5 is not supported). */
                                uint8_t                 *L,                 /*!< [in]  The label input pointer. Relevant for [PKCS1_2.1] only. NULL by default.
										       NULL for [PKCS1_1.5]. */
                                uint16_t              Llen,                 /*!< [in]  The label length. Relevant for [PKCS1_2.1] only. Zero by default.
										       Zero for [PKCS1_1.5]. */
                                CRYS_PKCS1_MGF_t        MGF,                /*!< [in]  The mask generation function. [PKCS1_2.1] defines MGF1, so the only
										       value allowed here is CRYS_PKCS1_MGF1. */
                                uint8_t              *DataIn_ptr,           /*!< [in]  Pointer to the data to decrypt. */
                                uint16_t              DataInSize,           /*!< [in]  The size (in bytes) of the data to decrypt. DataSize must be ≤
										       the modulus size. */
                                uint8_t              *Output_ptr,           /*!< [in]  Pointer to the decrypted data. The buffer must be at least
										       PrivKey_ptr->N.len bytes long (i.e. the modulus size in bytes). */
                                uint16_t             *OutputSize_ptr,       /*!< [in]  Pointer to the byte size of the buffer pointed to by Output_buffer.
										       The size must be:

 For PKCS #1 v2.1: Modulus size > OutputSize >=
												(modulus size - 2*HashLen - 2).

 For PKCS #1 v1.5: Modulus size > OutputSize >= (modulus size - 11).
                                                                                The value pointed by OutputSize_ptr is updated after decryption with
											the actual number of bytes that are loaded to Output_ptr.

 */
                                CRYS_PKCS1_version      PKCS1_ver           /*!< [in]  [PKCS1_1.5] or [PKCS1_2.1], according to the functionality required. */
);

/**********************************************************************************************************/
/**
   @brief
   CRYS_RSA_OAEP_Decrypt implements the RSAES-OAEP algorithm
   as defined in PKCS#1 v2.1 8.1.

   \note It is not recommended to use hash MD5 in OAEP PKCS1 ver 2.1, therefore
   it is not supported.

   This function combines the RSA decryption primitive and the
   EME-OAEP encoding method, to provide an RSA-based decryption
   method that is semantically secure against adaptive
   chosen-ciphertext attacks. For more details, please refer to
   the PKCS#1 standard.

*/
#define CRYS_RSA_OAEP_Decrypt(UserPrivKey_ptr,PrimeData_ptr,HashMode,L,Llen,MGF,Data_ptr,DataSize,Output_ptr,OutputSize_ptr)\
		SaSi_RsaSchemesDecrypt(UserPrivKey_ptr,PrimeData_ptr,HashMode,L,Llen,MGF,Data_ptr,DataSize,Output_ptr,OutputSize_ptr,CRYS_PKCS1_VER21)

/**
   @brief
   CRYS_RSA_PKCS1v15_Decrypt implements the RSAES-PKCS1v15 algorithm as defined
   in PKCS#1 v2.1 8.2.
*/
#define CRYS_RSA_PKCS1v15_Decrypt(UserPrivKey_ptr,PrimeData_ptr,DataIn_ptr,DataInSize,Output_ptr,OutputSize_ptr)\
		SaSi_RsaSchemesDecrypt(UserPrivKey_ptr,PrimeData_ptr,CRYS_RSA_HASH_NO_HASH_mode,NULL,0,CRYS_PKCS1_NO_MGF,DataIn_ptr,DataInSize,Output_ptr,OutputSize_ptr,CRYS_PKCS1_VER15)

/**********************************************************************************************************/
/*!
@brief Implements the Signing algorithm, as defined in [PKCS1_1.5] or [PKCS1_2.1], using a single function.

@return CRYS_OK on success.
@return A non-zero value from crys_rsa_error.h on failure.
*/
CIMPORT_C CRYSError_t SaSi_RsaSign(
                   CRYS_RND_Context_t *rndContext_ptr,              /*!< [in/out] Pointer to the RND context buffer. */
                   CRYS_RSAPrivUserContext_t *UserContext_ptr,      /*!< [in]  Pointer to a temporary context for internal use. */
                   CRYS_RSAUserPrivKey_t *UserPrivKey_ptr,          /*!< [in]  Pointer to the private key data structure of the user.
                                                                               The representation (pair or quintuple) and hence the algorithm (CRT or not CRT)
									       is determined by the Private Key build function -
                                                                               ::CRYS_RSA_Build_PrivKey or ::CRYS_RSA_Build_PrivKeyCRT. */
                   CRYS_RSA_HASH_OpMode_t rsaHashMode,              /*!< [in]  One of the supported SHA-x HASH modes, as defined in ::CRYS_RSA_HASH_OpMode_t.
									       (MD5 is not supported). */
                   CRYS_PKCS1_MGF_t MGF,                            /*!< [in]  The mask generation function. [PKCS1_2.1] defines only MGF1, so the only value
									       allowed for [PKCS1_2.1] is CRYS_PKCS1_MGF1. */
                   uint16_t     SaltLen,                            /*!< [in]  The Length of the Salt buffer (relevant for PKCS#1 Ver 2.1 only, typically lengths is 0 or hash Len).
                                                                               FIPS 186-4 requires, that SaltLen <= hash len. If SaltLen > KeySize - hash Len - 2, the function
                                                                               returns an error.  */
                   uint8_t     *DataIn_ptr,                         /*!< [in]  Pointer to the input data to be signed.
                                                                               The size of the scatter/gather list representing the data buffer is limited to 128
									       entries, and the size of each entry is limited to 64KB (fragments larger than
									       64KB are broken into fragments <= 64KB). */
                   uint32_t     DataInSize,                         /*!< [in]  The size (in bytes) of the data to sign. */
                   uint8_t     *Output_ptr,                         /*!< [out] Pointer to the signature. The buffer must be at least PrivKey_ptr->N.len bytes
									       long (i.e. the modulus size in bytes). */
                   uint16_t    *OutputSize_ptr,                     /*!< [in/out] Pointer to the signature size value - the input value is the signature
										  buffer size allocated, the output value is the signature size used.
                                                                                he buffer must be equal to PrivKey_ptr->N.len bytes long
										  (i.e. the modulus size in bytes). */
                   CRYS_PKCS1_version PKCS1_ver                     /*!< [in]  [PKCS1_1.5] or [PKCS1_2.1], according to the functionality required. */
);

/*!
@brief CRYS_RSA_PKCS1v15_Sign implements the RSASSA-PKCS1v15 algorithm as defined in PKCS#1 v1.5.

This function combines the RSASP1 signature primitive and the EMSA-PKCS1v15 encoding method, to provide an RSA-based signature scheme.
For more details, please refer to the PKCS#1 standard.
 */

#define CRYS_RSA_PKCS1v15_Sign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,hashFunc,DataIn_ptr,DataInSize,Output_ptr,OutputSize_ptr)\
		SaSi_RsaSign(rndContext_ptr, (UserContext_ptr),(UserPrivKey_ptr),(hashFunc),(CRYS_PKCS1_NO_MGF),0,(DataIn_ptr),(DataInSize),(Output_ptr),(OutputSize_ptr),CRYS_PKCS1_VER15)

/*!
@brief CRYS_RSA_PKCS1v15_SHA1_Sign implements the RSASSA-PKCS1v15 algorithm as defined in PKCS#1 v1.5, but without performing a HASH function -
it assumes that the data in has already been hashed using SHA-1.

\note The data_in size is already known after the Hash.
*/
#define CRYS_RSA_PKCS1v15_SHA1_Sign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,DataIn_ptr,Output_ptr,OutputSize_ptr)\
		SaSi_RsaSign(rndContext_ptr, (UserContext_ptr),(UserPrivKey_ptr),(CRYS_RSA_After_SHA1_mode),(CRYS_PKCS1_NO_MGF),0,(DataIn_ptr),CRYS_HASH_SHA1_DIGEST_SIZE_IN_BYTES,(Output_ptr),(OutputSize_ptr),CRYS_PKCS1_VER15)

/*!
@brief CRYS_RSA_PKCS1v15_MD5_Sign implements the RSASSA-PKCS1v15 algorithm as defined in PKCS#1 v1.5, but without performing a HASH function -
it assumes that the data in has already been hashed using MD5.

\note The data_in size is already known after the Hash.
*/

#define CRYS_RSA_PKCS1v15_MD5_Sign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,DataIn_ptr,Output_ptr,OutputSize_ptr)\
		SaSi_RsaSign(rndContext_ptr, (UserContext_ptr),(UserPrivKey_ptr),CRYS_RSA_After_MD5_mode,CRYS_PKCS1_NO_MGF,0,(DataIn_ptr),CRYS_HASH_MD5_DIGEST_SIZE_IN_BYTES,(Output_ptr),(OutputSize_ptr),CRYS_PKCS1_VER15)

/*!
@brief CRYS_RSA_PKCS1v15_SHA224_Sign implements the RSASSA-PKCS1v15 algorithm as defined in PKCS#1 v1.5, but without performing a HASH function -
it assumes that the data in has already been hashed using SHA-224.

\note The data_in size is already known after the Hash.
*/
#define CRYS_RSA_PKCS1v15_SHA224_Sign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,DataIn_ptr,Output_ptr,OutputSize_ptr)\
		SaSi_RsaSign(rndContext_ptr, (UserContext_ptr),(UserPrivKey_ptr),(CRYS_RSA_After_SHA224_mode),(CRYS_PKCS1_NO_MGF),0,(DataIn_ptr),CRYS_HASH_SHA224_DIGEST_SIZE_IN_BYTES,(Output_ptr),(OutputSize_ptr),CRYS_PKCS1_VER15)

/*!
@brief CRYS_RSA_PKCS1v15_SHA256_Sign implements the RSASSA-PKCS1v15 algorithm as defined in PKCS#1 v1.5, but without performing a HASH function -
it assumes that the data in has already been hashed using SHA-256.

\note The data_in size is already known after the Hash.
*/
#define CRYS_RSA_PKCS1v15_SHA256_Sign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,DataIn_ptr,Output_ptr,OutputSize_ptr)\
		SaSi_RsaSign(rndContext_ptr, (UserContext_ptr),(UserPrivKey_ptr),(CRYS_RSA_After_SHA256_mode),(CRYS_PKCS1_NO_MGF),0,(DataIn_ptr),CRYS_HASH_SHA256_DIGEST_SIZE_IN_BYTES,(Output_ptr),(OutputSize_ptr),CRYS_PKCS1_VER15)

/*!
@brief CRYS_RSA_PKCS1v15_SHA1_Sign implements the RSASSA-PKCS1v15 algorithm as defined in PKCS#1 v1.5, but without performing a HASH function -
it assumes that the data in has already been hashed using SHA-384.

\note The data_in size is already known after the Hash.
*/
#define CRYS_RSA_PKCS1v15_SHA384_Sign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,DataIn_ptr,Output_ptr,OutputSize_ptr)\
		SaSi_RsaSign(rndContext_ptr, (UserContext_ptr),(UserPrivKey_ptr),(CRYS_RSA_After_SHA384_mode),(CRYS_PKCS1_NO_MGF),0,(DataIn_ptr),CRYS_HASH_SHA384_DIGEST_SIZE_IN_BYTES,(Output_ptr),(OutputSize_ptr),CRYS_PKCS1_VER15)

/*!
@brief CRYS_RSA_PKCS1v15_SHA512_Sign implements the RSASSA-PKCS1v15 algorithm  as defined in PKCS#1 v1.5, but without performing a HASH function -
it assumes that the data in has already been hashed using SHA-512.

\note The data_in size is already known after the Hash.
*/
#define CRYS_RSA_PKCS1v15_SHA512_Sign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,DataIn_ptr,Output_ptr,OutputSize_ptr)\
		SaSi_RsaSign(rndContext_ptr, (UserContext_ptr),(UserPrivKey_ptr),(CRYS_RSA_After_SHA512_mode),(CRYS_PKCS1_NO_MGF),0,(DataIn_ptr),CRYS_HASH_SHA512_DIGEST_SIZE_IN_BYTES,(Output_ptr),(OutputSize_ptr),CRYS_PKCS1_VER15)

/*!
@brief CRYS_RSA_PSS_Sign implements the RSASSA-PSS algorithm as defined in PKCS#1 v2.1 9.1, in a single function call.

\note According to the PKCS#1 ver2.1 it is not recommended to use MD5 Hash, therefore it is not supported.

The actual macro that is used by the user is ::CRYS_RSA_PSS_Sign.
*/

#define CRYS_RSA_PSS_Sign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,hashFunc,MGF,SaltLen,DataIn_ptr,DataInSize,Output_ptr,OutputSize_ptr)\
		SaSi_RsaSign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,hashFunc,MGF,SaltLen,DataIn_ptr,DataInSize,Output_ptr,OutputSize_ptr,CRYS_PKCS1_VER21)

/*!
@brief CRYS_RSA_PSS_SHA1_Sign implements the RSASSA-PSS algorithm as defined in PKCS#1 v2.1 9.1 in a single function call, but without performing a HASH function -
it assumes that the data in has already been hashed using SHA-1.

\note The data_in size is already known after the Hash.

The actual macro that is used by the users is ::CRYS_RSA_PSS_SHA1_Sign.
*/

#define CRYS_RSA_PSS_SHA1_Sign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,MGF,SaltLen,DataIn_ptr,Output_ptr,OutputSize_ptr)\
		SaSi_RsaSign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,CRYS_RSA_After_SHA1_mode,MGF,SaltLen,DataIn_ptr,CRYS_HASH_SHA1_DIGEST_SIZE_IN_BYTES,Output_ptr,OutputSize_ptr,CRYS_PKCS1_VER21)

/*!
@brief CRYS_RSA_PSS_SHA224_Sign implements the RSASSA-PSS algorithm as defined in PKCS#1 v2.1 9.1 in a single function call, but without performing a HASH function -
it assumes that the data in has already been hashed using SHA-224.

\note The data_in size is already known after the Hash.

The actual macro that is used by the users is ::CRYS_RSA_PSS_SHA224_Sign.
*/

#define CRYS_RSA_PSS_SHA224_Sign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,MGF,SaltLen,DataIn_ptr,Output_ptr,OutputSize_ptr)\
		SaSi_RsaSign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,CRYS_RSA_After_SHA224_mode,MGF,SaltLen,DataIn_ptr,CRYS_HASH_SHA224_DIGEST_SIZE_IN_BYTES,Output_ptr,OutputSize_ptr,CRYS_PKCS1_VER21)

/*!
@brief CRYS_RSA_PSS_SHA256_Sign implements the RSASSA-PSS algorithm as defined in PKCS#1 v2.1 9.1 in a single function call, but without performing a HASH function -
it assumes that the data in has already been hashed using SHA-256.

\note The data_in size is already known after the Hash.

The actual macro that is used by the users is ::CRYS_RSA_PSS_SHA256_Sign.
*/

#define CRYS_RSA_PSS_SHA256_Sign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,MGF,SaltLen,DataIn_ptr,Output_ptr,OutputSize_ptr)\
		SaSi_RsaSign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,CRYS_RSA_After_SHA256_mode,MGF,SaltLen,DataIn_ptr,CRYS_HASH_SHA256_DIGEST_SIZE_IN_BYTES,Output_ptr,OutputSize_ptr,CRYS_PKCS1_VER21)

/*!
@brief CRYS_RSA_PSS_SHA384_Sign implements the RSASSA-PSS algorithm as defined in PKCS#1 v2.1 9.1 in a single function call, but without performing a HASH function -
it assumes that the data in has already been hashed using SHA-384.

\note The data_in size is already known after the Hash.

The actual macro that is used by the users is ::CRYS_RSA_PSS_SHA384_Sign.
*/

#define CRYS_RSA_PSS_SHA384_Sign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,MGF,SaltLen,DataIn_ptr,Output_ptr,OutputSize_ptr)\
		SaSi_RsaSign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,CRYS_RSA_After_SHA384_mode,MGF,SaltLen,DataIn_ptr,CRYS_HASH_SHA384_DIGEST_SIZE_IN_BYTES,Output_ptr,OutputSize_ptr,CRYS_PKCS1_VER21)

/*!
@brief CRYS_RSA_PSS_SHA512_Sign implements the RSASSA-PSS algorithm as defined in PKCS#1 v2.1 9.1 in a single function call, but without performing a HASH function -
it assumes that the data in has already been hashed using SHA-512.

\note The data_in size is already known after the Hash.

The actual macro that is used by the users is ::CRYS_RSA_PSS_SHA512_Sign.
*/

#define CRYS_RSA_PSS_SHA512_Sign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,MGF,SaltLen,DataIn_ptr,Output_ptr,OutputSize_ptr)\
		SaSi_RsaSign(rndContext_ptr, UserContext_ptr,UserPrivKey_ptr,CRYS_RSA_After_SHA512_mode,MGF,SaltLen,DataIn_ptr,CRYS_HASH_SHA512_DIGEST_SIZE_IN_BYTES,Output_ptr,OutputSize_ptr,CRYS_PKCS1_VER21)

/**********************************************************************************************************/
/*!
@brief Implements the RSA signature verification algorithms, in a single function call, as defined in referenced standards [PKCS1_1.5]
and [PKCS1_2.1].

@return CRYS_OK on success.
@return A non-zero value from crys_rsa_error.h on failure.
*/

CIMPORT_C CRYSError_t SaSi_RsaVerify(
                            CRYS_RSAPubUserContext_t *UserContext_ptr,      /*!< [in]  Pointer to a temporary context for internal use. */
                            CRYS_RSAUserPubKey_t *UserPubKey_ptr,           /*!< [in]  Pointer to the public key data structure of the user. */
                            CRYS_RSA_HASH_OpMode_t rsaHashMode,             /*!< [in]  One of the supported SHA-x HASH modes, as defined in ::CRYS_RSA_HASH_OpMode_t.
										       (MD5 is not supported). */
                            CRYS_PKCS1_MGF_t MGF,                           /*!< [in]  The mask generation function. [PKCS1_2.1] defines only MGF1, so the only
										       value allowed for [PKCS_2.1] is CRYS_PKCS1_MGF1. */
                            uint16_t SaltLen,                               /*!< [in]  The Length of the Salt buffer. Relevant only for [PKCS1_2.1].
										       Typical lengths are 0 or hash Len (20 for SHA-1).
                                                                                The maximum length allowed is [modulus size - hash Len - 2]. */
                            uint8_t     *DataIn_ptr,                        /*!< [in]  Pointer to the input data to be verified.
                                                                                The size of the scatter/gather list representing the data buffer is
											limited to 128 entries, and the size of each entry is limited to 64KB
											(fragments larger than 64KB are broken into fragments <= 64KB). */
                            uint32_t     DataInSize,                        /*!< [in]  The size (in bytes) of the data whose signature is to be verified. */
                            uint8_t     *Sig_ptr,                           /*!< [in]  Pointer to the signature to be verified.
                                                                                The length of the signature is PubKey_ptr->N.len bytes
										       (i.e. the modulus size in bytes). */
                            CRYS_PKCS1_version PKCS1_ver                    /*!< [in]  [PKCS1_1.5] or [PKCS1_2.1], according to the functionality required. */
);

#define CRYS_RSA_PKCS1v15_Verify(UserContext_ptr,UserPubKey_ptr,hashFunc,DataIn_ptr,DataInSize,Sig_ptr)\
		SaSi_RsaVerify(UserContext_ptr,UserPubKey_ptr,hashFunc,CRYS_PKCS1_NO_MGF,0,DataIn_ptr,DataInSize,Sig_ptr,CRYS_PKCS1_VER15)

/*!
@brief CRYS_RSA_PKCS1v15_MD5_Verify implements the RSASSA-PKCS1v15 Verify algorithm as defined in PKCS#1 v1.5, but without operating the HASH function -
it assumes the DataIn_ptr data has already been hashed using MD5.
*/

#define CRYS_RSA_PKCS1v15_MD5_Verify(UserContext_ptr,UserPubKey_ptr,DataIn_ptr,Sig_ptr)\
		SaSi_RsaVerify(UserContext_ptr,UserPubKey_ptr,CRYS_RSA_After_MD5_mode,CRYS_PKCS1_NO_MGF,0,DataIn_ptr,CRYS_HASH_MD5_DIGEST_SIZE_IN_BYTES,Sig_ptr,CRYS_PKCS1_VER15)

/*!
@brief CRYS_RSA_PKCS1v15_SHA1_Verify implements the RSASSA-PKCS1v15 Verify algorithm as defined in PKCS#1 v1.5, but without operating the HASH function -
it assumes that the DataIn_ptr data has already been hashed using SHA1.

*/
#define CRYS_RSA_PKCS1v15_SHA1_Verify(UserContext_ptr,UserPubKey_ptr,DataIn_ptr,Sig_ptr)\
		SaSi_RsaVerify(UserContext_ptr,UserPubKey_ptr,CRYS_RSA_After_SHA1_mode,CRYS_PKCS1_NO_MGF,0,DataIn_ptr,CRYS_HASH_SHA1_DIGEST_SIZE_IN_BYTES,Sig_ptr,CRYS_PKCS1_VER15)

/*!
@brief CRYS_RSA_PKCS1v15_SHA224_Verify implements the RSASSA-PKCS1v15 Verify algorithm as defined in PKCS#1 v1.5, but without operating the HASH function -
it assumes that the DataIn_ptr data has already been hashed using SHA224.

*/
#define CRYS_RSA_PKCS1v15_SHA224_Verify(UserContext_ptr,UserPubKey_ptr,DataIn_ptr,Sig_ptr)\
		SaSi_RsaVerify(UserContext_ptr,UserPubKey_ptr,CRYS_RSA_After_SHA224_mode,CRYS_PKCS1_NO_MGF,0,DataIn_ptr,CRYS_HASH_SHA224_DIGEST_SIZE_IN_BYTES,Sig_ptr,CRYS_PKCS1_VER15)

/*!
@brief CRYS_RSA_PKCS1v15_SHA256_Verify implements the RSASSA-PKCS1v15 Verify algorithm as defined in PKCS#1 v1.5, but without operating the HASH function -
it assumes that the DataIn_ptr data has already been hashed using SHA256.

*/
#define CRYS_RSA_PKCS1v15_SHA256_Verify(UserContext_ptr,UserPubKey_ptr,DataIn_ptr,Sig_ptr)\
		SaSi_RsaVerify(UserContext_ptr,UserPubKey_ptr,CRYS_RSA_After_SHA256_mode,CRYS_PKCS1_NO_MGF,0,DataIn_ptr,CRYS_HASH_SHA256_DIGEST_SIZE_IN_BYTES,Sig_ptr,CRYS_PKCS1_VER15)

/*!
@brief CRYS_RSA_PKCS1v15_SHA384_Verify implements the RSASSA-PKCS1v15 Verify algorithm as defined in PKCS#1 v1.5, but without operating the HASH function -
it assumes that the DataIn_ptr data has already been hashed using SHA384.

*/
#define CRYS_RSA_PKCS1v15_SHA384_Verify(UserContext_ptr,UserPubKey_ptr,DataIn_ptr,Sig_ptr)\
		SaSi_RsaVerify(UserContext_ptr,UserPubKey_ptr,CRYS_RSA_After_SHA384_mode,CRYS_PKCS1_NO_MGF,0,DataIn_ptr,CRYS_HASH_SHA384_DIGEST_SIZE_IN_BYTES,Sig_ptr,CRYS_PKCS1_VER15)

/*!
@brief CRYS_RSA_PKCS1v15_SHA512_Verify implements the RSASSA-PKCS1v15 Verify algorithm as defined in PKCS#1 v1.5, but without operating the HASH function -
it assumes that the DataIn_ptr data has already been hashed using SHA512.

*/
#define CRYS_RSA_PKCS1v15_SHA512_Verify(UserContext_ptr,UserPubKey_ptr,DataIn_ptr,Sig_ptr)\
		SaSi_RsaVerify(UserContext_ptr,UserPubKey_ptr,CRYS_RSA_After_SHA512_mode,CRYS_PKCS1_NO_MGF,0,DataIn_ptr,CRYS_HASH_SHA512_DIGEST_SIZE_IN_BYTES,Sig_ptr,CRYS_PKCS1_VER15)

/*!
@brief CRYS_RSA_PSS_Verify implements the RSASSA-PKCS1v21 Verify algorithm as defined in PKCS#1 v2.1.
*/

#define CRYS_RSA_PSS_Verify(UserContext_ptr,UserPubKey_ptr,hashFunc,MGF,SaltLen,DataIn_ptr,DataInSize,Sig_ptr)\
		SaSi_RsaVerify(UserContext_ptr,UserPubKey_ptr,hashFunc,MGF,SaltLen,DataIn_ptr,DataInSize,Sig_ptr,CRYS_PKCS1_VER21)

			      /*!
@brief CRYS_RSA_PSS_SHA1_Verify implements the PKCS1v21 Verify algorithm as defined in PKCS#1 v2.1, but without operating the HASH function -
it assumes the DataIn_ptr has already been hashed using SHA1.

*/

#define CRYS_RSA_PSS_SHA1_Verify(UserContext_ptr,UserPubKey_ptr,MGF,SaltLen,DataIn_ptr,Sig_ptr)\
		SaSi_RsaVerify(UserContext_ptr,UserPubKey_ptr,CRYS_RSA_After_SHA1_mode,MGF,SaltLen,DataIn_ptr,CRYS_HASH_SHA1_DIGEST_SIZE_IN_BYTES,Sig_ptr,CRYS_PKCS1_VER21)

/*!
@brief CRYS_RSA_PSS_SHA224_Verify implements the PKCS1v21 Verify algorithm as defined in PKCS#1 v2.1, but without operating the HASH function -
it assumes the DataIn_ptr has already been hashed using SHA224.
*/

#define CRYS_RSA_PSS_SHA224_Verify(UserContext_ptr,UserPubKey_ptr,MGF,SaltLen,DataIn_ptr,Sig_ptr)\
		SaSi_RsaVerify(UserContext_ptr,UserPubKey_ptr,CRYS_RSA_After_SHA224_mode,MGF,SaltLen,DataIn_ptr,CRYS_HASH_SHA224_DIGEST_SIZE_IN_BYTES,Sig_ptr,CRYS_PKCS1_VER21)

/*!
@brief CRYS_RSA_PSS_SHA256_Verify implements the PKCS1v21 Verify algorithm as defined in PKCS#1 v2.1, but without operating the HASH function -
it assumes the DataIn_ptr has already been hashed using SHA256.

*/

#define CRYS_RSA_PSS_SHA256_Verify(UserContext_ptr,UserPubKey_ptr,MGF,SaltLen,DataIn_ptr,Sig_ptr)\
		SaSi_RsaVerify(UserContext_ptr,UserPubKey_ptr,CRYS_RSA_After_SHA256_mode,MGF,SaltLen,DataIn_ptr,CRYS_HASH_SHA256_DIGEST_SIZE_IN_BYTES,Sig_ptr,CRYS_PKCS1_VER21)

/*!
@brief CRYS_RSA_PSS_SHA384_Verify implements the PKCS1v21 Verify algorithm as defined in PKCS#1 v2.1, but without operating the HASH function -
it assumes the DataIn_ptr has already been hashed using SHA384.

*/

#define CRYS_RSA_PSS_SHA384_Verify(UserContext_ptr,UserPubKey_ptr,MGF,SaltLen,DataIn_ptr,Sig_ptr)\
		SaSi_RsaVerify(UserContext_ptr,UserPubKey_ptr,CRYS_RSA_After_SHA384_mode,MGF,SaltLen,DataIn_ptr,CRYS_HASH_SHA384_DIGEST_SIZE_IN_BYTES,Sig_ptr,CRYS_PKCS1_VER21)

/*!
@brief CRYS_RSA_PSS_SHA512_Verify implements the PKCS1v21 Verify algorithm as defined in PKCS#1 v2.1, but without operating the HASH function -
it assumes the DataIn_ptr has already been hashed using SHA512.
*/

#define CRYS_RSA_PSS_SHA512_Verify(UserContext_ptr,UserPubKey_ptr,MGF,SaltLen,DataIn_ptr,Sig_ptr)\
		SaSi_RsaVerify(UserContext_ptr,UserPubKey_ptr,CRYS_RSA_After_SHA512_mode,MGF,SaltLen,DataIn_ptr,CRYS_HASH_SHA512_DIGEST_SIZE_IN_BYTES,Sig_ptr,CRYS_PKCS1_VER21)

/**********************************************************************************************************/

#ifdef __cplusplus
}
#endif

#endif


text:
// ******************************************
// *                                        *
// * THIS IS A GENERATED FILE. DO NOT EDIT! *
// * SEE .xml FILE WITH SAME NAME           *
// *                                        *
// ******************************************

#include "stdafx.h"
#include "zorbatypes/rchandle.h"
#include "zorbatypes/zstring.h"
#include "runtime/visitors/planiter_visitor.h"
#include "runtime/indexing/ic_ddl.h"
#include "system/globalenv.h"

#include "store/api/iterator.h"

namespace zorba {

// <ActivateICIterator>
SERIALIZABLE_CLASS_VERSIONS(ActivateICIterator)

void ActivateICIterator::serialize(::zorba::serialization::Archiver& ar)
{
  serialize_baseclass(ar,
  (UnaryBaseIterator<ActivateICIterator, PlanIteratorState>*)this);
}

void ActivateICIterator::accept(PlanIterVisitor& v) const
{
  v.beginVisit(*this);

  theChild->accept(v);

  v.endVisit(*this);
}

ActivateICIterator::~ActivateICIterator() {}

zstring ActivateICIterator::getNameAsString() const {
  return "zorba-store-static-integrity-constraints-ddl:activate";
}
// </ActivateICIterator>

// <DeactivateICIterator>
SERIALIZABLE_CLASS_VERSIONS(DeactivateICIterator)

void DeactivateICIterator::serialize(::zorba::serialization::Archiver& ar)
{
  serialize_baseclass(ar,
  (UnaryBaseIterator<DeactivateICIterator, PlanIteratorState>*)this);
}

void DeactivateICIterator::accept(PlanIterVisitor& v) const
{
  v.beginVisit(*this);

  theChild->accept(v);

  v.endVisit(*this);
}

DeactivateICIterator::~DeactivateICIterator() {}

zstring DeactivateICIterator::getNameAsString() const {
  return "zorba-store-static-integrity-constraints-ddl:deactivate";
}
// </DeactivateICIterator>

// <CheckICIterator>
SERIALIZABLE_CLASS_VERSIONS(CheckICIterator)

void CheckICIterator::serialize(::zorba::serialization::Archiver& ar)
{
  serialize_baseclass(ar,
  (UnaryBaseIterator<CheckICIterator, PlanIteratorState>*)this);
}

void CheckICIterator::accept(PlanIterVisitor& v) const
{
  v.beginVisit(*this);

  theChild->accept(v);

  v.endVisit(*this);
}

CheckICIterator::~CheckICIterator() {}

zstring CheckICIterator::getNameAsString() const {
  return "zorba-store-static-integrity-constraints-dml:check-integrity-constraint";
}
// </CheckICIterator>

}