text:
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.18444
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace OpenRiaServices.DomainServices.Server {
    using System;

    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class Resource {

        private static global::System.Resources.ResourceManager resourceMan;

        private static global::System.Globalization.CultureInfo resourceCulture;

        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal Resource() {
        }

        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("OpenRiaServices.DomainServices.Server.Data.Resource", typeof(Resource).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }

        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The property '{0}' of entity type '{1}' cannot be marked with AssociationAttribute because '{2}' is not a valid entity type..
        /// </summary>
        internal static string Association_Not_Entity_Type {
            get {
                return ResourceManager.GetString("Association_Not_Entity_Type", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Access to operation '{0}' was denied..
        /// </summary>
        internal static string AuthorizationAttribute_Default_Message {
            get {
                return ResourceManager.GetString("AuthorizationAttribute_Default_Message", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The '{0}' AuthorizationAttribute must specify a non-empty 'ErrorMessage' to access '{1}' resource type..
        /// </summary>
        internal static string AuthorizationAttribute_Requires_ErrorMessage {
            get {
                return ResourceManager.GetString("AuthorizationAttribute_Requires_ErrorMessage", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The resource type '{0}' does not expose a static string property named '{1}'..
        /// </summary>
        internal static string AuthorizationAttribute_Requires_Valid_Property {
            get {
                return ResourceManager.GetString("AuthorizationAttribute_Requires_Valid_Property", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to This AuthorizationContext instance is only a template and cannot be used directly.".
        /// </summary>
        internal static string AuthorizationContext_Template_Only {
            get {
                return ResourceManager.GetString("AuthorizationContext_Template_Only", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The specified entity does not exist in the ChangeSet..
        /// </summary>
        internal static string ChangeSet_ChangeSetEntryNotFound {
            get {
                return ResourceManager.GetString("ChangeSet_ChangeSetEntryNotFound", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid ChangeSet : Entity for operation '{0}' has multiple parents..
        /// </summary>
        internal static string ChangeSet_ChildHasMultipleParents {
            get {
                return ResourceManager.GetString("ChangeSet_ChildHasMultipleParents", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The member expression specified is invalid..
        /// </summary>
        internal static string ChangeSet_InvalidMemberExpression {
            get {
                return ResourceManager.GetString("ChangeSet_InvalidMemberExpression", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to GetOriginal cannot be called for a new entity being inserted..
        /// </summary>
        internal static string ChangeSet_OriginalNotValidForInsert {
            get {
                return ResourceManager.GetString("ChangeSet_OriginalNotValidForInsert", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Cannot replace entity of type '{0}' with entity of type '{1}'..
        /// </summary>
        internal static string ChangeSet_Replace_EntityTypesNotSame {
            get {
                return ResourceManager.GetString("ChangeSet_Replace_EntityTypesNotSame", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Composed type '{0}' can only have a Delete method if all of its parent types also support Update or Delete..
        /// </summary>
        internal static string Composition_ParentsMustSupportDelete {
            get {
                return ResourceManager.GetString("Composition_ParentsMustSupportDelete", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Composed type '{0}' can only have an Insert method if all of its parent types also support Update or Insert..
        /// </summary>
        internal static string Composition_ParentsMustSupportInsert {
            get {
                return ResourceManager.GetString("Composition_ParentsMustSupportInsert", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Composed type '{0}' can only have an Update method if all of its parent types also support Update..
        /// </summary>
        internal static string Composition_ParentsMustSupportUpdate {
            get {
                return ResourceManager.GetString("Composition_ParentsMustSupportUpdate", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The MetadataTypeAttribute on type '{0}' results in a cyclic metadata provider chain. Either remove the attribute or remove the cycle..
        /// </summary>
        internal static string CyclicMetadataTypeAttributesFound {
            get {
                return ResourceManager.GetString("CyclicMetadataTypeAttributesFound", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The property '{0}' of type '{1}' is marked with the KeyAttribute.  Derived entity classes cannot declare key properties..
        /// </summary>
        internal static string DerivedEntityCannotHaveKey {
            get {
                return ResourceManager.GetString("DerivedEntityCannotHaveKey", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The domain operation '{0}' declared on the entity '{1}' must also be declared on the root entity '{2}'..
        /// </summary>
        internal static string DomainOperation_Required_On_Root {
            get {
                return ResourceManager.GetString("DomainOperation_Required_On_Root", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The argument '{0}' cannot be null or empty..
        /// </summary>
        internal static string DomainOperationEntry_ArgumentCannotBeNullOrEmpty {
            get {
                return ResourceManager.GetString("DomainOperationEntry_ArgumentCannotBeNullOrEmpty", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to A method named '{0}' is already defined. DomainOperationEntry overloads are not supported..
        /// </summary>
        internal static string DomainOperationEntryOverload_NotSupported {
            get {
                return ResourceManager.GetString("DomainOperationEntryOverload_NotSupported", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to This DomainService has already been initialized..
        /// </summary>
        internal static string DomainService_AlreadyInitialized {
            get {
                return ResourceManager.GetString("DomainService_AlreadyInitialized", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The domain operation entry named '{0}' provides redundant functionality. Another method named '{1}' already exists..
        /// </summary>
        internal static string DomainService_DuplicateCUDMethod {
            get {
                return ResourceManager.GetString("DomainService_DuplicateCUDMethod", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Type '{0}' is not a valid DomainService type..
        /// </summary>
        internal static string DomainService_Factory_InvalidDomainServiceType {
            get {
                return ResourceManager.GetString("DomainService_Factory_InvalidDomainServiceType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to This DomainService does not support operation '{0}' for entity '{1}'..
        /// </summary>
        internal static string DomainService_InvalidDomainOperationEntry {
            get {
                return ResourceManager.GetString("DomainService_InvalidDomainOperationEntry", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to This DomainService has been initialized for an operation of type '{0}' so it cannot be used for an operation of type '{1}'..
        /// </summary>
        internal static string DomainService_InvalidOperationType {
            get {
                return ResourceManager.GetString("DomainService_InvalidOperationType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The type '{0}' is not a valid DomainService type. DomainService types cannot be abstract or generic..
        /// </summary>
        internal static string DomainService_InvalidType {
            get {
                return ResourceManager.GetString("DomainService_InvalidType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Multiple invocations of entity action '{0}.{1}' is not allowed.
        /// </summary>
        internal static string DomainService_MultipleEntityActionsNotAllowedFor {
            get {
                return ResourceManager.GetString("DomainService_MultipleEntityActionsNotAllowedFor", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to This DomainService has not been initialized..
        /// </summary>
        internal static string DomainService_NotInitialized {
            get {
                return ResourceManager.GetString("DomainService_NotInitialized", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to A service of type '{0}' already exists in the container..
        /// </summary>
        internal static string DomainServiceContextServiceContainer_ItemAlreadyExists {
            get {
                return ResourceManager.GetString("DomainServiceContextServiceContainer_ItemAlreadyExists", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The entity type '{0}' must be marked with DataContractAttribute since it derives from type '{1}' which is marked with DataContractAttribute..
        /// </summary>
        internal static string DomainServiceDescription_DataContractAttributeRequired {
            get {
                return ResourceManager.GetString("DomainServiceDescription_DataContractAttributeRequired", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Query operation '{0}' cannot be marked as the default because it returns only a single value..
        /// </summary>
        internal static string DomainServiceDescription_DefaultQuery_Cannot_Be_Singleton {
            get {
                return ResourceManager.GetString("DomainServiceDescription_DefaultQuery_Cannot_Be_Singleton", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Both query operations '{0}' and '{1}' cannot be marked as the default query operation because they return the same entity type '{2}'..
        /// </summary>
        internal static string DomainServiceDescription_DefaultQuery_Cannot_Have_Multiple {
            get {
                return ResourceManager.GetString("DomainServiceDescription_DefaultQuery_Cannot_Have_Multiple", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Both query operations '{0}' and '{1}' cannot be marked as the default query operation. Entity type '{2}' derives from entity type '{3}'.  The default query can expose only a single type for an entity hierarchy..
        /// </summary>
        internal static string DomainServiceDescription_DefaultQuery_Cannot_Have_Multiple_Inheritance {
            get {
                return ResourceManager.GetString("DomainServiceDescription_DefaultQuery_Cannot_Have_Multiple_Inheritance", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Query operation '{0}' cannot be marked as the default because it declares parameters..
        /// </summary>
        internal static string DomainServiceDescription_DefaultQuery_Cannot_Have_Params {
            get {
                return ResourceManager.GetString("DomainServiceDescription_DefaultQuery_Cannot_Have_Params", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The operation '{0}' cannot be added to this DomainServiceDescription for type '{1}' because the operation's DomainServiceType is '{2}'..
        /// </summary>
        internal static string DomainServiceDescription_IncompatibleOperationParentType {
            get {
                return ResourceManager.GetString("DomainServiceDescription_IncompatibleOperationParentType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to CompositionAttribute cannot be applied to member '{0}.{1}'. CompositionAttribute can only be applied to members marked with AssociationAttribute..
        /// </summary>
        internal static string DomainServiceDescription_InvalidCompositionMember {
            get {
                return ResourceManager.GetString("DomainServiceDescription_InvalidCompositionMember", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Modifications cannot be made to a DomainServiceDescription once it has been initialized..
        /// </summary>
        internal static string DomainServiceDescription_InvalidUpdate {
            get {
                return ResourceManager.GetString("DomainServiceDescription_InvalidUpdate", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Entity type '{0}' has more than one member marked with both TimestampAttribute and ConcurrencyCheckAttribute. An entity can have only one concurrency version member..
        /// </summary>
        internal static string DomainServiceDescription_MultipleVersionMembers {
            get {
                return ResourceManager.GetString("DomainServiceDescription_MultipleVersionMembers", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Query operation '{0}' cannot be marked composable since its return type '{1}' does not implement IEnumerable of T..
        /// </summary>
        internal static string DomainServiceDescription_SingletonQueryMethodCannotCompose {
            get {
                return ResourceManager.GetString("DomainServiceDescription_SingletonQueryMethodCannotCompose", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to This DomainServiceDescription hasn't been initialized. Initialize must be called before the description can be used..
        /// </summary>
        internal static string DomainServiceDescription_Uninitialized {
            get {
                return ResourceManager.GetString("DomainServiceDescription_Uninitialized", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to DomainServiceDescriptionProvider type '{0}' must have a constructor with two parameters of types 'Type' and 'DomainServiceDescriptionProvider', in that order..
        /// </summary>
        internal static string DomainServiceDescriptionProviderAttribute_MissingConstructor {
            get {
                return ResourceManager.GetString("DomainServiceDescriptionProviderAttribute_MissingConstructor", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The Entity '{0}' in DomainService '{1}' does not have a key defined. Entity types exposed by DomainService operations must have at least one public property marked with the KeyAttribute..
        /// </summary>
        internal static string Entity_Has_No_Key_Properties {
            get {
                return ResourceManager.GetString("Entity_Has_No_Key_Properties", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Property '{0}.{1}' is already defined by '{2} and cannot be redefined..
        /// </summary>
        internal static string Entity_Property_Redefined {
            get {
                return ResourceManager.GetString("Entity_Property_Redefined", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Association '{0}.{1}' is marked with RequiredAttribute. Please remove the attribute and mark the underlying foreign key members with RequiredAttribute instead..
        /// </summary>
        internal static string Entity_RequiredAssociationNotAllowed {
            get {
                return ResourceManager.GetString("Entity_RequiredAssociationNotAllowed", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Entity types cannot be a collection type..
        /// </summary>
        internal static string EntityTypes_Cannot_Be_Collections {
            get {
                return ResourceManager.GetString("EntityTypes_Cannot_Be_Collections", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Entity types cannot be generic..
        /// </summary>
        internal static string EntityTypes_Cannot_Be_Generic {
            get {
                return ResourceManager.GetString("EntityTypes_Cannot_Be_Generic", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Entity types cannot be nullable..
        /// </summary>
        internal static string EntityTypes_Cannot_Be_Nullable {
            get {
                return ResourceManager.GetString("EntityTypes_Cannot_Be_Nullable", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Entity types cannot be a primitive type or a simple type like string or Guid..
        /// </summary>
        internal static string EntityTypes_Cannot_Be_Primitives {
            get {
                return ResourceManager.GetString("EntityTypes_Cannot_Be_Primitives", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Entity types must be public..
        /// </summary>
        internal static string EntityTypes_Must_Be_Public {
            get {
                return ResourceManager.GetString("EntityTypes_Must_Be_Public", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Entity types must have a default constructor..
        /// </summary>
        internal static string EntityTypes_Must_Have_Default_Constructor {
            get {
                return ResourceManager.GetString("EntityTypes_Must_Have_Default_Constructor", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Incorrect parameter type '{0}' for parameter '{1}'. Expected type is '{2}'..
        /// </summary>
        internal static string IncorrectParameterType {
            get {
                return ResourceManager.GetString("IncorrectParameterType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Entity '{0}' has a property '{1}' with an unsupported type..
        /// </summary>
        internal static string Invalid_Entity_Property {
            get {
                return ResourceManager.GetString("Invalid_Entity_Property", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Type '{0}' is not a valid entity type.  {1}.
        /// </summary>
        internal static string Invalid_Entity_Type {
            get {
                return ResourceManager.GetString("Invalid_Entity_Type", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Member '{0}.{1}' is an optimistic concurrency check member, but is either excluded or non-serializable..
        /// </summary>
        internal static string Invalid_Exclude_Property_Concurency_Conflict {
            get {
                return ResourceManager.GetString("Invalid_Exclude_Property_Concurency_Conflict", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The property '{0}' in entity type '{1}' cannot be marked with the IncludeAttribute because '{2}' is not a valid entity type.  {3}.
        /// </summary>
        internal static string Invalid_Include_Invalid_Entity {
            get {
                return ResourceManager.GetString("Invalid_Include_Invalid_Entity", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Association '{0}' defined on entity type '{1}' is invalid. It is a foreign key association but the property type is not a singleton..
        /// </summary>
        internal static string InvalidAssociation_FKNotSingleton {
            get {
                return ResourceManager.GetString("InvalidAssociation_FKNotSingleton", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Association named '{0}' defined on entity type '{1}' is invalid: one and only one side of the association must have IsForeignKey set to true..
        /// </summary>
        internal static string InvalidAssociation_IsFKInvalid {
            get {
                return ResourceManager.GetString("InvalidAssociation_IsFKInvalid", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Association named '{0}' defined on entity type '{1}' is invalid: the number of keys in '{2}' does not match the number in '{3}'..
        /// </summary>
        internal static string InvalidAssociation_Key_Count_Mismatch {
            get {
                return ResourceManager.GetString("InvalidAssociation_Key_Count_Mismatch", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Association defined on property '{0}' of entity '{1}' is invalid: Name cannot be null or empty..
        /// </summary>
        internal static string InvalidAssociation_NameCannotBeNullOrEmpty {
            get {
                return ResourceManager.GetString("InvalidAssociation_NameCannotBeNullOrEmpty", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Association name '{0}' defined on entity type '{1}' is not unique..
        /// </summary>
        internal static string InvalidAssociation_NonUniqueAssociationName {
            get {
                return ResourceManager.GetString("InvalidAssociation_NonUniqueAssociationName", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Association named '{0}' defined on entity type '{1}' is invalid: OtherKey property named '{2}' cannot be found on entity type '{3}'..
        /// </summary>
        internal static string InvalidAssociation_OtherKeyNotFound {
            get {
                return ResourceManager.GetString("InvalidAssociation_OtherKeyNotFound", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Association named '{0}' defined on entity type '{1}' is invalid: Association members cannot be marked with RoundtripOriginalAttribute..
        /// </summary>
        internal static string InvalidAssociation_RoundTripOriginal {
            get {
                return ResourceManager.GetString("InvalidAssociation_RoundTripOriginal", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Association named '{0}' defined on entity type '{1}' is invalid: {2} cannot be null or empty..
        /// </summary>
        internal static string InvalidAssociation_StringCannotBeNullOrEmpty {
            get {
                return ResourceManager.GetString("InvalidAssociation_StringCannotBeNullOrEmpty", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Association named '{0}' defined on entity type '{1}' is invalid: ThisKey property named '{2}' cannot be found..
        /// </summary>
        internal static string InvalidAssociation_ThisKeyNotFound {
            get {
                return ResourceManager.GetString("InvalidAssociation_ThisKeyNotFound", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Association '{0}' defined on entity type '{1}' is invalid. The corresponding association on '{2}' is not a valid back reference..
        /// </summary>
        internal static string InvalidAssociation_TypesDoNotAlign {
            get {
                return ResourceManager.GetString("InvalidAssociation_TypesDoNotAlign", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid ChangeSet : {0}.
        /// </summary>
        internal static string InvalidChangeSet {
            get {
                return ResourceManager.GetString("InvalidChangeSet", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Id '{0}' specified for association member  '{0}.{1}' is invalid..
        /// </summary>
        internal static string InvalidChangeSet_AssociatedIdNotInChangeset {
            get {
                return ResourceManager.GetString("InvalidChangeSet_AssociatedIdNotInChangeset", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Associated Ids for member '{0}.{1}' cannot be null..
        /// </summary>
        internal static string InvalidChangeSet_AssociatedIdsCannotBeNull {
            get {
                return ResourceManager.GetString("InvalidChangeSet_AssociatedIdsCannotBeNull", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Only one entry for a given entity instance can exist in the ChangeSet..
        /// </summary>
        internal static string InvalidChangeSet_DuplicateEntity {
            get {
                return ResourceManager.GetString("InvalidChangeSet_DuplicateEntity", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Id must be unique for each entry..
        /// </summary>
        internal static string InvalidChangeSet_DuplicateId {
            get {
                return ResourceManager.GetString("InvalidChangeSet_DuplicateId", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to OriginalEntity cannot be specified for an Insert operation..
        /// </summary>
        internal static string InvalidChangeSet_InsertsCantHaveOriginal {
            get {
                return ResourceManager.GetString("InvalidChangeSet_InsertsCantHaveOriginal", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Association member '{0}.{1}' specified in the ChangeSet does not exist or is not marked with AssociationAttribute..
        /// </summary>
        internal static string InvalidChangeSet_InvalidAssociationMember {
            get {
                return ResourceManager.GetString("InvalidChangeSet_InvalidAssociationMember", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Entity and OriginalEntity must be of the same type..
        /// </summary>
        internal static string InvalidChangeSet_MustBeSameType {
            get {
                return ResourceManager.GetString("InvalidChangeSet_MustBeSameType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Entity cannot be null..
        /// </summary>
        internal static string InvalidChangeSet_NullEntity {
            get {
                return ResourceManager.GetString("InvalidChangeSet_NullEntity", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Child entity of type '{0}' cannot be updated independent of its parent..
        /// </summary>
        internal static string InvalidChangeset_UpdateChildWithoutParent {
            get {
                return ResourceManager.GetString("InvalidChangeset_UpdateChildWithoutParent", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Complex types cannot have association members..
        /// </summary>
        internal static string InvalidComplexType_AssociationMember {
            get {
                return ResourceManager.GetString("InvalidComplexType_AssociationMember", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Complex types cannot have composition members..
        /// </summary>
        internal static string InvalidComplexType_CompositionMember {
            get {
                return ResourceManager.GetString("InvalidComplexType_CompositionMember", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to DomainService '{0}' exposes both entity type '{1}' and complex type '{2}' which share an inheritance relationship. Entities cannot derive from complex types..
        /// </summary>
        internal static string InvalidComplexType_EntityInheritance {
            get {
                return ResourceManager.GetString("InvalidComplexType_EntityInheritance", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Complex types cannot have include members..
        /// </summary>
        internal static string InvalidComplexType_IncludeMember {
            get {
                return ResourceManager.GetString("InvalidComplexType_IncludeMember", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to DomainService '{0}' exposes both complex type '{1}' and complex type '{2}' which share an inheritance relationship. Only one complex type in an inheritance hierarchy can be exposed from a domain service..
        /// </summary>
        internal static string InvalidComplexType_Inheritance {
            get {
                return ResourceManager.GetString("InvalidComplexType_Inheritance", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Complex type '{0}' is invalid. Complex types cannot specify a KnownTypeAttribute..
        /// </summary>
        internal static string InvalidComplexType_KnownTypes {
            get {
                return ResourceManager.GetString("InvalidComplexType_KnownTypes", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Property '{0}' of complex type '{1}' is invalid. {2}.
        /// </summary>
        internal static string InvalidComplexType_PropertyAttribute {
            get {
                return ResourceManager.GetString("InvalidComplexType_PropertyAttribute", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Custom methods must contain at least one parameter..
        /// </summary>
        internal static string InvalidCustomMethod_MethodCannotBeParameterless {
            get {
                return ResourceManager.GetString("InvalidCustomMethod_MethodCannotBeParameterless", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Parameter '{0}' of domain method '{1}' must be an entity type exposed by the DomainService. The entity type can be exposed either directly in a query operation, or indirectly through an association..
        /// </summary>
        internal static string InvalidDomainMethod_ParamMustBeEntity {
            get {
                return ResourceManager.GetString("InvalidDomainMethod_ParamMustBeEntity", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid return type '{0}' for query method '{1}'. Query methods must have a return type that implements IEnumerable of T or must return a singleton..
        /// </summary>
        internal static string InvalidDomainOperationEntry_InvalidQueryOperationReturnType {
            get {
                return ResourceManager.GetString("InvalidDomainOperationEntry_InvalidQueryOperationReturnType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to DomainOperationEntry '{0}' is not a Query operation so it cannot return a value..
        /// </summary>
        internal static string InvalidDomainOperationEntry_NonQueryMustReturnVoid {
            get {
                return ResourceManager.GetString("InvalidDomainOperationEntry_NonQueryMustReturnVoid", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Parameter '{1}' of domain operation entry '{0}' must be passed by value..
        /// </summary>
        internal static string InvalidDomainOperationEntry_ParamMustBeByVal {
            get {
                return ResourceManager.GetString("InvalidDomainOperationEntry_ParamMustBeByVal", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Parameter '{1}' of domain operation entry '{0}' must be one of the predefined serializable types..
        /// </summary>
        internal static string InvalidDomainOperationEntry_ParamMustBeSimple {
            get {
                return ResourceManager.GetString("InvalidDomainOperationEntry_ParamMustBeSimple", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to '{0}' is not a valid DomainOperation type for a DomainOperationEntry..
        /// </summary>
        internal static string InvalidDomainOperationEntryType {
            get {
                return ResourceManager.GetString("InvalidDomainOperationEntryType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to '{0}' is not a valid DomainOperation type for a ChangeSetEntry..
        /// </summary>
        internal static string InvalidDomainOperationType {
            get {
                return ResourceManager.GetString("InvalidDomainOperationType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid External specification for member '{0}.{1}'. ExternalReferenceAttribute can only be specified on members with the AssociationAttribute applied..
        /// </summary>
        internal static string InvalidExternal_NonAssociationMember {
            get {
                return ResourceManager.GetString("InvalidExternal_NonAssociationMember", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid Include specification for member '{0}.{1}'. Non-projection includes can only be specified on members with the AssociationAttribute applied..
        /// </summary>
        internal static string InvalidInclude_NonAssociationMember {
            get {
                return ResourceManager.GetString("InvalidInclude_NonAssociationMember", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Domain operation entry '{0}' must take exactly one parameter..
        /// </summary>
        internal static string InvalidInsertUpdateDeleteMethod_IncorrectParameterLength {
            get {
                return ResourceManager.GetString("InvalidInsertUpdateDeleteMethod_IncorrectParameterLength", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Operation named '{0}' does not conform to the required signature. Parameter types must be an entity or complex type, a collection of entities or complex types, or one of the predefined serializable types..
        /// </summary>
        internal static string InvalidInvokeOperation_ParameterType {
            get {
                return ResourceManager.GetString("InvalidInvokeOperation_ParameterType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Operation named '{0}' does not conform to the required signature. Return types must be an entity or complex type, a collection of entities or complex types, or one of the predefined serializable types..
        /// </summary>
        internal static string InvalidInvokeOperation_ReturnType {
            get {
                return ResourceManager.GetString("InvalidInvokeOperation_ReturnType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid member projection specification : MemberName cannot be empty..
        /// </summary>
        internal static string InvalidMemberProjection_EmptyMemberName {
            get {
                return ResourceManager.GetString("InvalidMemberProjection_EmptyMemberName", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid member projection specification : Path cannot be empty..
        /// </summary>
        internal static string InvalidMemberProjection_EmptyPath {
            get {
                return ResourceManager.GetString("InvalidMemberProjection_EmptyPath", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid member projection specification : The type of member '{0}.{1}' projected from member '{2}.{3}' is not one of the predefined serializable types..
        /// </summary>
        internal static string InvalidMemberProjection_InvalidProjectedType {
            get {
                return ResourceManager.GetString("InvalidMemberProjection_InvalidProjectedType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid member projection specification : Projection path '{0}' is invalid for member '{1}.{2}'. Please verify that the 'Path' value specified in the IncludeAttribute on this member is correct. .
        /// </summary>
        internal static string InvalidMemberProjection_Path {
            get {
                return ResourceManager.GetString("InvalidMemberProjection_Path", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Type '{0}' does not derive from '{1}'..
        /// </summary>
        internal static string InvalidType {
            get {
                return ResourceManager.GetString("InvalidType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The derived entity type '{0}' must be declared in a KnownTypeAttribute on the root entity '{1}'..
        /// </summary>
        internal static string KnownTypeAttributeRequired {
            get {
                return ResourceManager.GetString("KnownTypeAttributeRequired", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The entity type '{0}' in the DomainService '{1}' is abstract and must use a KnownTypeAttribute to specify at least one non-abstract derived type..
        /// </summary>
        internal static string KnownTypeAttributeRequired_Abstract {
            get {
                return ResourceManager.GetString("KnownTypeAttributeRequired_Abstract", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Member '{0}.{1}' is not an compositional association member marked with CompositionAttribute..
        /// </summary>
        internal static string MemberNotAComposition {
            get {
                return ResourceManager.GetString("MemberNotAComposition", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Member '{0}.{1}' is not an association member marked with AssociationAttribute..
        /// </summary>
        internal static string MemberNotAnAssociation {
            get {
                return ResourceManager.GetString("MemberNotAnAssociation", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Method '{0}' requires {1} parameters..
        /// </summary>
        internal static string Method_Parameter_Count_Wrong {
            get {
                return ResourceManager.GetString("Method_Parameter_Count_Wrong", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to One or more roles must be specified..
        /// </summary>
        internal static string RequiresRoleAttribute_MustSpecifyRole {
            get {
                return ResourceManager.GetString("RequiresRoleAttribute_MustSpecifyRole", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Ambiguous match for method '{0}'..
        /// </summary>
        internal static string ValidationUtilities_AmbiguousMatch {
            get {
                return ResourceManager.GetString("ValidationUtilities_AmbiguousMatch", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to ValidationContext.ObjectInstance cannot be null..
        /// </summary>
        internal static string ValidationUtilities_ContextInstance_CannotBeNull {
            get {
                return ResourceManager.GetString("ValidationUtilities_ContextInstance_CannotBeNull", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Method '{0}.{1}({3})' could not be found. Parameter count: {2}..
        /// </summary>
        internal static string ValidationUtilities_MethodNotFound {
            get {
                return ResourceManager.GetString("ValidationUtilities_MethodNotFound", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Method '{0}.{1}' accepting zero parameters could not be found..
        /// </summary>
        internal static string ValidationUtilities_MethodNotFound_ZeroParams {
            get {
                return ResourceManager.GetString("ValidationUtilities_MethodNotFound_ZeroParams", resourceCulture);
            }
        }
    }
}


text:
void remove_dir_loop(char *);
void check_dir_loop(char *, int);

#endif

redpajama_set_name: RedPajamaGithub


text: Proyecto de Gestión para escuela de aviación


text:
set -euo pipefail

# DESCRIPTION:
#
# This script is meant to launch GCE nodes, run bootkube to bootstrap a self-hosted k8s cluster, then run conformance tests.
#
# REQUIREMENTS:
#  - gcloud cli is installed
#  - rkt is available on the host
#
# REQUIRED ENV VARS:
#  - $BUILD_ROOT: contains a checkout of bootkube at $BUILD_ROOT/bootkube
#  - $KEY_FILE:   path to GCE service account keyfile
#
# OPTIONAL ENV VARS:
#  - $COREOS_VERSION:   CoreOS image version.
#
# PROCESS:
#
# Inside a rkt container:
#   - Use gcloud to launch master node
#     - Use the quickstart init-master.sh script to run bootkube on that node
#   - Use gcloud to launch worker node(s)
#     - Use the quickstart init-node.sh script to join node to kubernetes cluster
#   - Run conformance tests against the launched cluster
#
COREOS_CHANNEL=${COREOS_CHANNEL:-'coreos-stable'}
WORKER_COUNT=4
SELF_HOST_ETCD=${SELF_HOST_ETCD:-false}

GCE_PREFIX=${GCE_PREFIX:-'bootkube-ci'}
GCE_SERVICE_ACCOUNT=${GCE_SERVICE_ACCOUNT:-'bootkube-ci'}
GCE_PROJECT=${GCE_PROJECT:-coreos-gce-testing}

function cleanup {
    gcloud compute instances delete --quiet --zone us-central1-a ${GCE_PREFIX}-m1 || true
    gcloud compute firewall-rules delete --quiet ${GCE_PREFIX}-api-443 || true
    for i in $(seq 1 ${WORKER_COUNT}); do
        gcloud compute instances delete --quiet --zone us-central1-a ${GCE_PREFIX}-w${i} || true
    done
    rm -rf /build/cluster
}

function init {
    curl https://storage.googleapis.com/cloud-sdk-release/google-cloud-sdk-148.0.1-linux-x86_64.tar.gz > google-cloud-sdk.tar.gz
    tar xzf google-cloud-sdk.tar.gz
    ./google-cloud-sdk/install.sh
    source ~/.bashrc
    gcloud config set project ${GCE_PROJECT}
    gcloud auth activate-service-account ${GCE_SERVICE_ACCOUNT}@${GCE_PROJECT}.iam.gserviceaccount.com --key-file=/build/keyfile
    apt-get update && apt-get install -y jq

    ssh-keygen -t rsa -f /root/.ssh/id_rsa -N ""
    awk '{print "core:" $1 " " $2 " core@conformance"}' /root/.ssh/id_rsa.pub > /root/.ssh/gce-format.pub
}

function add_master {
    gcloud compute instances create ${GCE_PREFIX}-m1 \
        --image-project coreos-cloud --image-family ${COREOS_CHANNEL} --zone us-central1-a --machine-type n1-standard-4 --boot-disk-size=30GB

    gcloud compute instances add-tags --zone us-central1-a ${GCE_PREFIX}-m1 --tags ${GCE_PREFIX}-apiserver
    gcloud compute firewall-rules create ${GCE_PREFIX}-api-443 --target-tags=${GCE_PREFIX}-apiserver --allow tcp:443

    gcloud compute instances add-metadata ${GCE_PREFIX}-m1 --zone us-central1-a --metadata-from-file ssh-keys=/root/.ssh/gce-format.pub

    MASTER_IP=$(gcloud compute instances list ${GCE_PREFIX}-m1 --format=json | jq --raw-output '.[].networkInterfaces[].accessConfigs[].natIP')
    cd /build/bootkube/hack/quickstart && SSH_OPTS="-o StrictHostKeyChecking=no" \
        CLUSTER_DIR=/build/cluster SELF_HOST_ETCD=${SELF_HOST_ETCD} ./init-master.sh ${MASTER_IP}
}

function add_workers {
    #TODO (aaron): parallelize launching workers
    for i in $(seq 1 ${WORKER_COUNT}); do
        echo "Launching worker"
        gcloud compute instances create ${GCE_PREFIX}-w${i} \
            --image-project coreos-cloud --image-family ${COREOS_CHANNEL} --zone us-central1-a --machine-type n1-standard-2 --boot-disk-size=15GB

        echo "Adding ssh-key to worker metadata"
        gcloud compute instances add-metadata ${GCE_PREFIX}-w${i} --zone us-central1-a --metadata-from-file ssh-keys=/root/.ssh/gce-format.pub

        echo "Waiting 30s before retrieving worker metadata"
        sleep 30 # TODO(aaron) Have seen "Too many authentication failures" in CI jobs. This seems to help, but should dig into why
        echo "Getting worker public IP"
        local WORKER_IP=$(gcloud compute instances list ${GCE_PREFIX}-w${i} --format=json | jq --raw-output '.[].networkInterfaces[].accessConfigs[].natIP')
        cd /build/bootkube/hack/quickstart && SSH_OPTS="-o StrictHostKeyChecking=no" ./init-node.sh ${WORKER_IP} /build/cluster/auth/kubeconfig
    done
}

IN_CONTAINER=${IN_CONTAINER:-false}
if [ "${IN_CONTAINER}" == true ]; then
    #TODO(aaron): should probably run cleanup as part of init (not just on exit). Or add some random identifier to objects created during this run.
    trap cleanup EXIT
    init
    add_master
    add_workers
    KUBECONFIG=/etc/kubernetes/kubeconfig WORKER_COUNT=${WORKER_COUNT} /build/bootkube/hack/tests/conformance-test.sh ${MASTER_IP} 22 /root/.ssh/id_rsa
else
    BUILD_ROOT=${BUILD_ROOT:-}
    if [ -z "$BUILD_ROOT" ]; then
        echo "BUILD_ROOT must be set"
        exit 1
    fi
    if [ -z "$KEY_FILE" ]; then
        echo "KEY_FILE must be set"
        exit 1
    fi

    RKT_OPTS=$(echo \
        "--volume buildroot,kind=host,source=${BUILD_ROOT} " \
        "--mount volume=buildroot,target=/build " \
        "--volume keyfile,kind=host,source=${KEY_FILE} " \
        "--mount volume=keyfile,target=/build/keyfile " \
    )

    #TODO(pb): See if there is a way to make the --inherit-env option replace
    #passing all the variables manually.
    sudo rkt run --insecure-options=image ${RKT_OPTS} docker://golang:1.7.5 --exec /bin/bash -- -c \
        "IN_CONTAINER=true COREOS_CHANNEL=${COREOS_CHANNEL} GCE_PREFIX=${GCE_PREFIX} GCE_SERVICE_ACCOUNT=${GCE_SERVICE_ACCOUNT} GCE_PROJECT=${GCE_PROJECT} SELF_HOST_ETCD=${SELF_HOST_ETCD} /build/bootkube/hack/tests/$(basename $0)"
fi


text:
package ru.sigma.test.learning.basics;

/**
 * Created with IntelliJ IDEA.
 * User: emaltsev
 * Date: 20.11.13
 * Time: 11:54
 * To change this template use File | Settings | File Templates.
 */
public class ConditionalDemo {
    public static void main(String[] args) {
        int value1 = 1;
        int value2 = 2;
        if ((value1 == 1) && (value2 == 2))
            System.out.println("value1 is 1 AND value2 is 2");
        if ((value1 == 1) || (value2 == 1))
            System.out.println("value1 is 1 OR value2 is 1");

        int result;
        boolean someCondition = true;
        result = someCondition ? value1 : value2;
        System.out.println(result);
    }
}


text:
<?xml version="1.0" encoding="US-ASCII"?>
<!DOCTYPE rfc SYSTEM "rfc2629.dtd">

<rfc category="info" docName="sp-zerotier-mapping-01">

  <front>

    <title abbrev="ZeroTier mapping for SPs">
    ZeroTier Mapping for Scalability Protocols
    </title>

    <author fullname="Garrett D'Amore" initials="G." role="editor"
            surname="D'Amore">
      <address>
        <email>garrett@damore.org</email>
      </address>
    </author>

    <date month="October" year="2016" />

    <area>Applications</area>
    <workgroup>Internet Engineering Task Force</workgroup>

    <keyword>ZeroTier</keyword>
    <keyword>SP</keyword>

    <abstract>
      <t>This document defines the ZeroTier mapping for scalability protocols.</t>
    </abstract>

  </front>

  <middle>

      <t>ZeroTier expresses an 802.3 style layer 2, where frames
      maybe exchanged as if they were Ethernet frames. Virtual broadcast
      domains are created within a numbered "network", and frames may then
      be exchanged with any peers on that network.</t>

      <t>Frames may arrive in any order, or be lost, just a with Ethernet
      (best effort delivery), but they are strongly protected by a
      cryptographic checksum, so frames that do arrive will be uncorrupted.
      Furthermore, ZeroTier guarantees that a given frame will
      be received at most once.</t>

      <t>Each application on a ZeroTier network has its own address, called
      a ZeroTier ID (ZTID), which is globally unique -- this is generated from
      a hash of the public key associated with the application.</t>

      <t>A given application may participate in multiple ZeroTier networks.</t>

      <t>We assume each nanomsg application will have it's own ZeroTier ID,
      and will not use more than one.  Management of these IDs, as well as
      the underlying key pairs, is out of scope of this document.</t>

      <t>ZeroTier networks have a maximum payload MTU of 2800 bytes.
      However they also have an "optimum" MTU, based upon the underlying
      networks (typically UDP) and overheads that are used to exchange
      such packets.  For our purposes we will assume this to be approximately
      1400 bytes.  These values can change on different networks.</t>

        <t>Each nanomsg message sent over ZeroTier will be comprised of one
        or more fragments, where each fragment is mapped to a single
        underlying ZeroTier L2 frame.  We use the EtherType field
        of 0901 to indicate nanomsg over ZeroTier protocol (number to
        registered with IEEE).</t>

        <t>Each frame shall be prepended with the following header:</t>

           <artwork>
 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|              destination mac address (bytes 0-3)              |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|  destination mac (bytes 4-5)  |    source mac (bytes 0-1)     |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                   source mac address (bytes 2-5)              |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|    0x90       |   0x01        |  op   | flags |   version     |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|        fragment offset        |       fragment length         |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|        destination port       |         source port           |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|          type                 |           message ID          |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|       payload...
+-+-+-+-+-+-+-+-

           </artwork>

        <t>All numeric fields are in big-endian byte order.</t>

        <t>As above, the start of each frame is just as a normal Ethernet
        frame, with destination, source, and type of 0x901.</t>

        <t>The op is a field that indicates the type of message
        being sent.  The following values are defined: DATA (0),
        CONN (1), DISC (2), PING (3), and ERR (4).  These are discussed
        further below. Implementations MUST discard messages where the
        op is not one of these.</t>

        <t>There are two flags defined.  The first is MF (1), which
        indicates that a message is fragmented, and more fragments follow.
        This flag may only be set on DATA messages.  The last fragment
        of a message will not have this flag set.</t>

        <t>The second flag is AK (2), which indicates that a
        given message is a reply to an earlier message.  This is
        only valid for the CONN, DISC, and PING message types.</t>

        <t>Note that the MF and the AK flag bits are mutually exclusive.</t>

        <t>The version byte MUST be set to 0x1.  Implementations MUST
        discard any messages received for any other version.</t>

        <t>The fragment length and offset are given in terms of octets,
        and only include the payload.  For example, the first fragment
        of a message bearing a 2000 byte payload, itself only carrying
        1400 bytes of that payload would have the MF bit set in flags,
	offset 0, and length 1400.  The second fragment would have the MF
	bit clear, length 600, and offset 1400.</t>

        <t>As a single fragment cannot exceed the size of a ZeroTier frame,
        the high order six bits of the fragment length MUST be zero, and
        the value encoded MUST be less than 2800.</t>

        <t>Each fragment for a given message must carry the same
        message ID.  Implementations MUST initialize this to a random
        value, and MUST increment this each time a new message is sent.</t>

        <t>The port fields are used to discriminate different uses, allowing
        one application to have multiple connections or sockets open.
        The purpose is analogous to TCP port numbers, except that instead
        of the operating system performing the discrimination the application
        or library code must do so.</t>

        <t>The type field is the numeric SP protocol ID, in big-endian
        form.  When receiving a message for a port, if the SP protocol ID
        does not match the SP protocol expected on that port, the
        implementation MUST discard this message.</t>

        <t>The maximum payload size, and hence the maximum SP message that
        may be transmitted using this transport, is 65535 octets.
        Implementations are encouraged to restrict this further.</t>

        <t>Note that it is not by accident that the payload is 32-bit
        aligned in this message format.</t>

        <t>Source and destination MAC addresses shall be constructed
        algorithmically from the relevant ZeroTier IDs.</t>

        <t>Note that at this time, broadcast and multicast is not supported
        by this mapping. (A future update may resolve this.)</t>

        <t>DATA messages carry SP protocol payload data.  They can only
        be sent on an established session (see CONN messages below),
        and are never acknowledged.</t>

        <t>CONN frames represent a session establishment.  They allow
        a peer to advertise its port number to a remote peer, and to verify
        that a peer is responsive.  The payload for the CONN frame is a 4
        byte (big-endian) value, consisting of the SP protocol ID of the
        sender.</t>

        <t>The connection is initiated by the initiator sending this
        message, with its own SP protocol ID. The AK flag will in this
        case be clear.</t>

        <t>The responder will acknowledge this by replying with its
        SP protocol ID in the 4-byte payload, with the AK flag set.</t>

        <t>Alternatively, a responder may reject the connection attempt by
        sending a suitably formed ERR message (see below).</t>

        <t>If a sender does not receive a reply, it SHOULD retry this
        message before giving up and reporting an error to the user.</t>

        <t>If a CONN frame is received for a session that already
        exists, the receiver MUST reply.  The CONN request is idempotent.</t>

        <t>DISC messages are used to request a session be terminated.
        This notifies the remote sender that no more data will be
        sent or accepted, and the session resources may be released.
        There is no payload.  The party closing the session sends this
        with the AK flag clear.  There is no acknowledgement.</t>

        <t>In order to keep session state, implementations will generally
        store data for each session.  In order to prevent a stale session
        from consuming these resources forever, and in order to keep
        underlying ZeroTier sessions alive, a PING message may be sent.
        This message has no payload.</t>

        <t>The sender MUST leave the AK bit clear.  If the PING is
        is successful, then the responder MUST reply with a PING message
        with the AK bit set.</t>

        <t>In the event of an error, an implemenation MAY reply with an
        ERR message.</t>

        <t>Implementations MUST not initiate PING messages if they have
        either received or sent other session messages recently.</t>

        <t>Implemenations shall use a timeout T1 seconds of be used
        before initiating a message the first time, and that in the absence
        of a reply, up to N further attempts be made, separated by T2 seconds.
        If no reply to the Nth attempt is received after T2 seconds have
        passed, then the remote peer should be assumed offline or dead, and
        the session closed.</t>

        <t>It is recommended that T1, T2, and N all be configurable, with
        recommended default values of 60, 10, and 5.  With these values,
        sessions that appear dead after 2 minutes will be closed, and their
        resources reclaimed.</t>

        <t>ERR messages indicate a failure in the session, and abruptly
        terminates the session.  The payload for these messages consists
        of a single byte error code, followed by an ASCII message describing
        the error (not terminated by zero).  This message shall not be
        more than 128 bytes in length.</t>

        <t>The following error codes are defined:

           <list>
           <t>0x01 No party listening at that address or port.</t>
           <t>0x02 No such session found.</t>
           <t>0x03 SP protocol ID invalid.</t>
           <t>0x04 Generic protocol error.</t>
           <t>0x05 Message size too big.</t>
           <t>0xff Other uncategorized error.</t>
           </list>
        </t>

        <t>Implemenations MUST discard any session state upon receiving an
        ERR message.  These messages are not acknowledged.</t>

        <t>Implementations MUST accept and reassemble fragmented DATA messages.
        Implementations MUST discard fragmented messages of other types.</t>

        <t>Messages larger than the ZeroTier MTU (2800) MUST be fragmented.</t>

        <t>Implementations SHOULD limit the number of unassembled messages
        retained for reassembly, to minimize the likelihood of intentional
        abuse.  It is suggested that at most 2 unassembled messages be
        retained.  It is further suggested that if 2 or more unfragmented
        messages arrive before a message is reassembled, or more than 5
        seconds pass before the reassembly is complete, that the unassembled
        fragments be discarded.</t>

        <t>The port numbers are 16-bit fields, allowing a single ZT ID to
        service multiple application layer protocols, which could be
        treated as seperate end points, or as separate sockets in the
        application.  The implementation is responsible for discriminating
        on these and delivering to the appropriate consumer.</t>

        <t>As with UDP or TCP, it is intended that each party have its own
        port number, and that a pair of ports (combined with ZeroTier IDs)
        be used to identify a single conversation.</t>

        <t>An SP server should allocate a port for number advertisement.
        It is expected cliets will generate ephemeral port numbers.</t>

        <t>Implementations are free to choose how to allocate port numbers,
        but it is recommended manually configured port numbers are small,
        with the high order bit clear, and that numbers > 32768 (high order
        bit set) be used for ephemeral allocations.</t>

        <t>It is recommended that separate short queues (perhaps just one
        or two messages long) be kept per local port in implementations, to
        prevent head-of-line blocking issues where backpressure on one
        consumer (perhaps just a single thread or socket) blocks others.</t>

       <t>The URI scheme used to represent ZeroTier addresses makes
       use of ZeroTier IDs, ZeroTier network IDs, and our own 16-bit
       ports.</t>

       <t>The format shall be nnzt://<nwid>/<ztid>:<port>,
       where the <nwid>
       component represents the 16-digit hexadecimal ZeroTier network ID, the
       <ztid> represents the 10-digit hexadecimal ZeroTier Device ID, and the
       <port> is the 16-bit port number previously described.</t>

      <t>This memo includes no request to IANA.</t>

      <t>The mapping isn't intended to provide any additional security in
         addition to what ZeroTier does.</t>

  </middle>

</rfc>


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<title>aspguidc.exception.input</title>
<meta name="date" content="2017-06-19">
<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Skip navigation links

Overview

Package

Class

Tree

Deprecated

Index

Help

Prev Package

Next Package

Frames

No Frames

All Classes

Package aspguidc.exception.input

Exception Summary

Exception
Description

InvalidProgramArgumentsException

Signals that the program was called with invalid arguments.

WrongNumberOfGuiCommentsException

Signals that the logic program contains a wrong number of gui definition comments.

Skip navigation links

Overview

Package

Class

Tree

Deprecated

Index

Help

Prev Package

Next Package

Frames

No Frames

All Classes


text:
package io.memento.infra.repository.note;

import io.memento.domain.model.Note;
import io.memento.infra.repository.note.NoteRepositoryCustom;

import javax.inject.Named;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import java.util.List;

@Named
public class NoteRepositoryImpl implements NoteRepositoryCustom {

    @PersistenceContext
    private EntityManager em;

    @Override
    public long count(String pattern) {
        String expression = "" +
                "select n.id from Note n " +
                "where n.content like :pattern " +
                "or n.title like :pattern " +
                "or n.description like :pattern " +
                "order by n.creationDate desc";
        TypedQuery<Long> query = em.createQuery(expression, Long.class);
        query.setParameter("pattern", "%" + pattern + "%");
        return query.getResultList().size();
    }

    @Override
    public List<Note> findLastNotesOrderByCreationDateDesc(int number) {
        TypedQuery<Note> query = em.createQuery("from Note order by creationDate desc", Note.class).setMaxResults(number);
        return query.getResultList();
    }

    @Override
    public Iterable<Note> findNotes(int offset, int size) {
        String expression = "" +
                "select n from Note n " +
                "order by n.creationDate desc";
        TypedQuery<Note> query = em.createQuery(expression, Note.class);
        query.setFirstResult(offset);
        query.setMaxResults(size);
        return query.getResultList();
    }

    @Override
    public Iterable<Note> findNotes(String pattern, int offset, int size) {
        String expression = "" +
                "select n from Note n " +
                "where n.content like :pattern " +
                "or n.title like :pattern " +
                "or n.description like :pattern " +
                "order by n.creationDate desc";
        TypedQuery<Note> query = em.createQuery(expression, Note.class);
        query.setParameter("pattern", "%" + pattern + "%");
        query.setFirstResult(offset);
        query.setMaxResults(size);
        return query.getResultList();
    }

}


text:
public class WordDictionary {
  static class TrieNode {
    boolean isWord;
    TrieNode[] children;
    TrieNode() { this.children = new TrieNode['z' - 'a' + 1]; }

    public void addWord(char[] word) {
      int index = 0;
      TrieNode node = this;
      while (index < word.length) {
        if (node.children[word[index] - 'a'] == null) {
          node.children[word[index] - 'a'] = new TrieNode();
        }
        node = node.children[word[index] - 'a'];
        if (index == word.length - 1) node.isWord = true;
        index++;
      }
    }

    public boolean exists(char[] word) {
      return exists(this, word, word.length, 0);
    }

    private boolean exists(TrieNode node, char[] word, int len, int index) {
      if (node == null || index > len) return false;
      if (index == len) return node.isWord;
      if (word[index] != '.') {
        return exists(node.children[word[index] - 'a'], word, len, index + 1);
      } else {
        for (TrieNode child : node.children) {
          if (exists(child, word, len, index + 1)) {
            return true;
          }
        }
        return false;
      }
    }
  }

  TrieNode root;

  /** Initialize your data structure here. */
  public WordDictionary() {
    root = new TrieNode();
  }

  /** Adds a word into the data structure. */
  public void addWord(String word) {
    root.addWord(word.toCharArray());
  }

  /**
   * Returns if the word is in the data structure.
   * A word could contain the dot character '.' to represent any one letter.
   */
  public boolean search(String word) {
    return root.exists(word.toCharArray());
  }
}

///////////////////////////////////////////////////////////////
// More verbose approach, but gives slightly faster solution
///////////////////////////////////////////////////////////////

public class WordDictionary {
  static class TrieNode {
    char value;
    boolean isWord;
    TrieNode[] children;
    TrieNode() { this.children = new TrieNode['z' - 'a' + 1]; }
    TrieNode(char value) { this(); this.value = value; }

    public void addWord(char[] word) {
      int index = 0;
      TrieNode node = this;
      while (index < word.length) {
        if (node.children[word[index] - 'a'] == null) {
          node.children[word[index] - 'a'] = new TrieNode(word[index]);
        }
        node = node.children[word[index] - 'a'];
        if (index == word.length - 1) node.isWord = true;
        index++;
      }
    }

    public boolean exists(char[] word) {
      return exists(word, 0);
    }

    private boolean exists(char[] word, int index) {
      if (index >= word.length) return false;
      char t = word[index];
      if (t != '.') {
        if (this.children[word[index] - 'a'] == null) return false;
        TrieNode node = this.children[word[index] - 'a'];
        if (index == word.length - 1) return node.isWord;
        return node.exists(word, index + 1);
      } else {
        for (TrieNode node : this.children) {
          if (index != word.length - 1 && node != null && node.exists(word, index + 1)) {
            return true;
          } else if (index == word.length - 1 && node != null && node.isWord) {
            return true;
          }
        }
        return false;
      }
    }
  }

  TrieNode root;

  /** Initialize your data structure here. */
  public WordDictionary() {
    root = new TrieNode();
  }

  /** Adds a word into the data structure. */
  public void addWord(String word) {
    root.addWord(word.toCharArray());
  }

  /**
   * Returns if the word is in the data structure.
   * A word could contain the dot character '.' to represent any one letter.
   */
  public boolean search(String word) {
    return root.exists(word.toCharArray());
  }
}

///////////////////////////////////////////////////////////////
// Faster solution, beats 98.69% of submission
///////////////////////////////////////////////////////////////

class WordDictionary {

  static class TrieNode {
    TrieNode[] children;
    boolean eow;

    TrieNode() {
      this.children = new TrieNode[26];
      this.eow = false;
    }
  }

  private TrieNode root;

  /** Initialize your data structure here. */
  public WordDictionary() {
    this.root = new TrieNode();
  }

  /** Adds a word into the data structure. */
  public void addWord(String word) {
    TrieNode tmp = this.root;
    for (int i = 0; i < word.length(); i++) {
      int t = word.charAt(i) - 'a';
      if (tmp.children[t] == null) {
        tmp.children[t] = new TrieNode();
      }
      tmp = tmp.children[t];
      if (i == word.length() - 1) {
        tmp.eow = true;
      }
    }
  }

  private boolean search(TrieNode n, String word, int pos) {
    for (int i = pos; i < word.length(); i++) {
      int t = word.charAt(i) - 'a';
      if (t < 0) {
        boolean res = false;
        for (TrieNode c : n.children) {
          if (c != null) {
            res = res || search(c, word, i + 1);
          }
        }
        return res;
      } else {
        if (n.children[t] == null) return false;
        n = n.children[t];
      }
    }
    return n.eow;
  }

  /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
  public boolean search(String word) {
    return search(this.root, word, 0);
  }
}

/**
 * Your WordDictionary object will be instantiated and called as such:
 * WordDictionary obj = new WordDictionary();
 * obj.addWord(word);
 * boolean param_2 = obj.search(word);
 */