///////////////////////////////////////////////////////////////////////
public bool CanBePresent(
OptionDictionary options, /* NOT USED */
ref Result error
)
{
if (HasFlags(OptionFlags.Unsupported, true))
{
error = String.Format(
"option \"{0}\" not supported for this platform",
name);
return(false);
}
if (HasFlags(OptionFlags.Disabled, true))
{
error = String.Format(
"option \"{0}\" is disabled",
name);
return(false);
}
return(true);
}
///////////////////////////////////////////////////////////////////////
private static ReturnCode ToClass2(
Interpreter interpreter,
Type type, /* NOT USED */
string text,
OptionDictionary options, /* NOT USED */
CultureInfo cultureInfo, /* NOT USED */
IClientData clientData, /* NOT USED */
ref MarshalFlags marshalFlags, /* NOT USED */
ref object value, /* Sample.Class2 */
ref Result error
)
{
long token = 0;
ICommand command = null;
if (interpreter.GetCommand(
text, LookupFlags.NoWrapper, ref token, ref command,
ref error) == ReturnCode.Ok)
{
value = command;
return(ReturnCode.Ok);
}
return(ReturnCode.Error);
}
public AliasData(
string nameToken,
Interpreter sourceInterpreter,
Interpreter targetInterpreter,
INamespace sourceNamespace,
INamespace targetNamespace,
IExecute target,
ArgumentList arguments,
OptionDictionary options,
AliasFlags aliasFlags,
int startIndex,
long token
)
{
this.kind = IdentifierKind.AliasData;
this.id = AttributeOps.GetObjectId(this);
this.nameToken = nameToken;
this.sourceInterpreter = sourceInterpreter;
this.targetInterpreter = targetInterpreter;
this.sourceNamespace = sourceNamespace;
this.targetNamespace = targetNamespace;
this.target = target;
this.arguments = arguments;
this.options = options;
this.aliasFlags = aliasFlags;
this.startIndex = startIndex;
this.token = token;
}
public void IndexerAddsNewElementForNewKey()
{
var dictionary = new OptionDictionary <string, string>();
dictionary["key"] = "value";
Assert.That(dictionary["key"].GetOrElse(""), Is.EqualTo("value"));
}
public void IndexerAddsOptionNone()
{
var dictionary = new OptionDictionary <string, string>();
dictionary["key"] = Option.None <string>();
Assert.That(dictionary["key"].IsNone, Is.True);
}
public void IndexerReturnsNoneIfKeyNotFound()
{
var dictionary = new OptionDictionary <string, string>();
Option <string> option = dictionary["missing-key"];
Assert.That(option.IsNone, Is.True);
}
public void IndexerReturnsNoneIfKeyNull()
{
var dictionary = new OptionDictionary <string, int>();
Option <int> option = dictionary[null];
Assert.That(option.IsNone, Is.True);
}
public void AddReturnsTrueIfSuccessfullyAdded()
{
var dictionary = new OptionDictionary <string, string>();
var result = dictionary.Add("key", "value");
Assert.That(result, Is.True);
}
public void IndexerAddsNothingIfKeyIsNull()
{
var dictionary = new OptionDictionary <string, string>();
dictionary[null] = "value";
Assert.That(dictionary, Is.Empty);
}
public void CanAddKeyAndValueToDictionary()
{
var dictionary =
new OptionDictionary <string, string> {
{ "key", "value" }
};
Assert.That(dictionary["key"].GetOrElse(""), Is.EqualTo("value"));
}
public void CanTestContainsKeyWhenKeyDoesNotExist()
{
var dictionary = new OptionDictionary <string, string>
{
{ "key", "value" }
};
Assert.That(dictionary.ContainsKey("other-key"), Is.False);
}
public void CanTestContainsKeyWhenKeyExists()
{
var dictionary = new OptionDictionary <string, string>
{
{ "key", "value" }
};
Assert.That(dictionary.ContainsKey("key"), Is.True);
}
///////////////////////////////////////////////////////////////////////
#region Public Constructors
public BinderClientData(
object data,
OptionDictionary options,
IClientData clientData
)
: this(data)
{
this.options = options;
this.clientData = clientData;
}
private OptionDictionary <T> GetOptionCollection <T>()
{
Type type = typeof(T);
if (!m_collections.ContainsKey(type))
{
m_collections[type] = new OptionDictionary <T>();
}
return((OptionDictionary <T>)m_collections[type]);
}
public void RemoveReturnsTrueIfElementisRemoved()
{
var dictionary = new OptionDictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" },
{ "key3", "value3" }
};
Assert.That(dictionary.Remove("key2"), Is.True);
}
public void CanCountNumberOfElements()
{
var dictionary = new OptionDictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" },
{ "key3", "value3" }
};
Assert.That(dictionary.Count, Is.EqualTo(3));
}
public void IndexerOverwritesValueForExistingKey()
{
var dictionary = new OptionDictionary <string, string>
{
{ "key", "value" }
};
dictionary["key"] = "other-value";
Assert.That(dictionary["key"].GetOrElse(""), Is.EqualTo("other-value"));
}
public void AddReturnsFalseIfKeyAlreadyAdded()
{
var dictionary = new OptionDictionary <string, string>
{
{ "key", "value" }
};
var result = dictionary.Add("key", "other-value");
Assert.That(result, Is.False);
}
public void CanClearAllElements()
{
var dictionary = new OptionDictionary <string, string>
{
{ "key", "value" }
};
dictionary.Clear();
Assert.That(dictionary, Is.Empty);
}
public void DoesNotAddElementIfKeyAlreadyAdded()
{
var dictionary = new OptionDictionary <string, string>
{
{ "key", "value" },
{ "key", "other-value" }
};
Assert.That(dictionary, Has.Count.EqualTo(1));
Assert.That(dictionary["key"].GetOrElse(""), Is.EqualTo("value"));
}
public void IndexerOverwritesIfSetToNone()
{
var dictionary = new OptionDictionary <string, string>
{
{ "key", "value" }
};
dictionary["key"] = Option.None <string>();
Assert.That(dictionary["key"].IsNone, Is.True);
}
public T Get <T>(string key)
{
OptionDictionary <T> options = GetOptionCollection <T>();
if (!options.ContainsKey(key) || IsOverrideIsRequired(key))
{
T value = GetDefaultValue <T>(key);
options[key] = value;
}
return(options[key]);
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region Internal Constructors
#if NETWORK
internal ChannelStream(
TcpListener listener,
ChannelType channelType,
OptionDictionary options,
StreamFlags flags
)
: this()
{
this.listener = listener;
this.channelType = channelType;
this.options = options;
this.flags = flags;
}
public void CanGetValueOfElementByItsKey()
{
var dictionary = new OptionDictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" },
{ "key3", "value3" }
};
Option <string> value = dictionary["key2"];
Assert.That(value.GetOrElse(""), Is.EqualTo("value2"));
}
public void CanGetCollectionOfKeys()
{
var dictionary = new OptionDictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" },
{ "key3", "value3" }
};
var keys = dictionary.Keys;
Assert.That(keys, Is.EquivalentTo(new[] { "key1", "key2", "key3" }));
}
///////////////////////////////////////////////////////////////////////
#region Public Constructors
public MarshalClientData(
object data,
OptionDictionary options,
MarshalFlags marshalFlags,
ReturnCode returnCode,
Result result
)
: this(data)
{
this.options = options;
this.marshalFlags = marshalFlags;
this.returnCode = returnCode;
this.result = result;
}
public void Set <T>(string key, T value)
{
OptionDictionary <T> optionDictionary = GetOptionCollection <T>();
T oldValue;
if (optionDictionary.TryGetValue(key, out oldValue))
{
if (oldValue != null && oldValue.Equals(value))
{
return;
}
}
optionDictionary[key] = value;
}
///////////////////////////////////////////////////////////////////////////////////////////////
#if NETWORK
public Channel(
TcpListener listener,
ChannelType channelType,
OptionDictionary options,
StreamFlags flags,
IClientData clientData
)
: this()
{
this.stream = new ChannelStream(
listener, channelType, options, flags);
this.encoding = null;
this.appendMode = false;
this.autoFlush = false;
this.clientData = clientData;
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region Public Constructors
public ChannelStream(
Stream stream,
ChannelType channelType,
OptionDictionary options,
StreamFlags flags,
StreamTranslation inTranslation,
StreamTranslation outTranslation
)
: this()
{
this.stream = stream;
this.channelType = channelType;
this.options = options;
this.flags = flags;
this.inTranslation = inTranslation;
this.outTranslation = outTranslation;
}
///////////////////////////////////////////////////////////////////////
public bool IsPresent(
OptionDictionary options, /* NOT USED */
ref Variant value
)
{
if (HasFlags(OptionFlags.Present, true))
{
if (MustHaveValue(options))
{
value = this.value;
}
return(true);
}
return(false);
}
