public virtual File copyTo(File to, Map options)
{
// sanity
if (isDir() != to.isDir())
{
if (isDir())
{
throw ArgErr.make("copyTo must be dir `" + to + "`").val;
}
else
{
throw ArgErr.make("copyTo must not be dir `" + to + "`").val;
}
}
// options
object exclude = null, overwrite = null;
if (options != null)
{
exclude = options.get(optExclude);
overwrite = options.get(optOverwrite);
}
// recurse
doCopyTo(to, exclude, overwrite);
return(to);
}
//////////////////////////////////////////////////////////////////////////
// Factory
//////////////////////////////////////////////////////////////////////////
/// <summary>
/// Parse the signature into a loaded type.
/// </summary>
public static Type load(string sig, bool check, Pod loadingPod)
{
// if last character is ?, then parse a nullable
int len = sig.Length;
int last = len > 1 ? sig[len - 1] : 0;
if (last == '?')
{
return(load(sig.Substring(0, len - 1), check, loadingPod).toNullable());
}
// if the last character isn't ] or |, then this a non-generic
// type and we don't even need to allocate a parser
if (last != ']' && last != '|')
{
string podName, typeName;
try
{
int colon = sig.IndexOf(':');
if (sig[colon + 1] != ':')
{
throw new System.Exception();
}
podName = sig.Substring(0, colon);
typeName = sig.Substring(colon + 2);
if (podName.Length == 0 || typeName.Length == 0)
{
throw new System.Exception();
}
}
catch (System.Exception)
{
throw ArgErr.make("Invalid type signature '" + sig + "', use <pod>::<type>").val;
}
// if the type is from the pod being loaded then return to the pod
if (loadingPod != null && podName == loadingPod.name())
{
return(loadingPod.type(typeName, check));
}
// do a straight lookup
return(find(podName, typeName, check));
}
// we got our work cut out for us - create parser
try
{
return(new TypeParser(sig, check, loadingPod).LoadTop());
}
catch (Err.Val e)
{
throw e;
}
catch (System.Exception)
{
throw Err(sig).val;
}
}
public virtual File moveInto(File dir)
{
if (!dir.isDir())
{
throw ArgErr.make("Not a dir: `" + dir + "`").val;
}
return(moveTo(dir.plusNameOf(this)));
}
public virtual File copyInto(File dir, Map options)
{
if (!dir.isDir())
{
throw ArgErr.make("Not a dir: `" + dir + "`").val;
}
return(copyTo(dir.plusNameOf(this), options));
}
//////////////////////////////////////////////////////////////////////////
// Retype
//////////////////////////////////////////////////////////////////////////
public Func retype(Type t)
{
try
{
return(new Wrapper((FuncType)t, this));
}
catch (System.InvalidCastException)
{
throw ArgErr.make("Not a Func type: " + t).val;
}
}
public void send(UdpSocket fan, UdpPacket packet)
{
// map buf bytes to packet
MemBuf data = (MemBuf)packet.data();
byte[] buf = data.m_buf;
int off = data.m_pos;
int len = data.m_size - off;
// map address, port
IpAddr addr = packet.addr();
Long port = packet.port();
if (isConnected(fan))
{
if (addr != null || port != null)
{
throw ArgErr.make("Address and port must be null to send while connected").val;
}
try
{
m_dotnet.Send(buf, off, len, SocketFlags.None);
}
catch (SocketException e)
{
throw IOErr.make(e).val;
}
}
else
{
if (addr == null || port == null)
{
throw ArgErr.make("Address or port is null").val;
}
try
{
if (m_dotnet == null)
{
m_dotnet = createSocket();
}
IPEndPoint endPoint = new IPEndPoint(addr.m_peer.m_dotnet, port.intValue());
m_dotnet.SendTo(buf, off, len, SocketFlags.None, endPoint);
}
catch (SocketException e)
{
throw IOErr.make(e).val;
}
}
// lastly drain buf
data.m_pos += len;
}
public static IpAddr makeBytes(Buf bytes)
{
try
{
MemBuf mb = bytes as MemBuf;
IPAddress dotnet = new IPAddress(mb.bytes());
return(make(dotnet.ToString(), dotnet));
}
catch (SocketException e)
{
throw ArgErr.make(e.Message).val;
}
}
private CachedProps refresh(Key key, CachedProps cp)
{
List files = m_env.findAllFiles(Uri.fromStr("etc/" + key.m_pod + "/" + key.m_uri));
if (cp != null && !cp.isStale(files))
{
return(cp);
}
if (key.m_uri.isPathAbs())
{
throw ArgErr.make("Env.props Uri must be relative: " + key.m_uri).val;
}
cp = new CachedProps(key, files);
m_cache[key] = cp;
return(cp);
}
public string toLocale(string pattern)
{
if (pattern == null)
{
return(localeAbbr());
}
if (FanStr.isEveryChar(pattern, 'W'))
{
switch (pattern.Length)
{
case 3: return(localeAbbr());
case 4: return(localeFull());
}
}
throw ArgErr.make("Invalid pattern: " + pattern).val;
}
//////////////////////////////////////////////////////////////////////////
// Bind
//////////////////////////////////////////////////////////////////////////
public Func bind(List args)
{
if (args.sz() == 0)
{
return(this);
}
if (args.sz() > @params().sz())
{
throw ArgErr.make("args.size > params.size").val;
}
Type[] newParams = new Type[@params().sz() - args.sz()];
for (int i = 0; i < newParams.Length; ++i)
{
newParams[i] = ((Param)@params().get(args.sz() + i)).m_type;
}
FuncType newType = new FuncType(newParams, this.returns());
return(new BindFunc(newType, this, args));
}
public override object get(Uri uri, object @base)
{
// don't support anything but relative fan: URIs right now
if (uri.auth() == null)
{
throw ArgErr.make("Invalid format for fan: URI - " + uri).val;
}
// lookup pod
string podName = (string)uri.auth();
Pod pod = Pod.find(podName, false);
if (pod == null)
{
throw UnresolvedErr.make(uri.toStr()).val;
}
if (uri.pathStr().Length == 0)
{
return(pod);
}
// dive into file of pod
return(pod.file(uri));
}
private static Err Err(string sig)
{
return(ArgErr.make("Invalid type signature '" + sig + "'"));
}
